Merge pull request #1 in RMS/api-main-service from red-develop to master

* commit 'fea7c857':
  added group and modules key at application endpoint
  Move each viewset to separate file and added new field code for Application model
  Replaced None in message response result with []
  Modified status messages for no records
  Added status response in utils, CRUD for services and endpoint models
  Added APIServices CRUD
  Complete Application CRUD, Added service_token for APIServices
  Update model fields, pagination, serializer validations and viewset CRUDs

.gitignore

@@ -30,3 +30,6 @@ local_*.py
 .venv
 venv/
 ENV/
+
+#vscode
+.vscode/

api/migrations/0001_initial.py

-# Generated by Django 2.1.5 on 2019-01-11 16:21
+# Generated by Django 2.1.5 on 2019-05-15 11:23
 
 from django.db import migrations, models
 import django.db.models.deletion
@@ -16,12 +16,16 @@ class Migration(migrations.Migration):
             name='APIEndpoint',
             fields=[
                 ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('name', models.CharField(max_length=200, unique=True)),
+                ('api_endpoint_no', models.CharField(max_length=250)),
+                ('name', models.CharField(max_length=200)),
                 ('description', models.CharField(blank=True, max_length=255, null=True)),
                 ('http_method', models.CharField(max_length=100)),
                 ('endpoint_url', models.CharField(max_length=200)),
                 ('is_need_auth', models.BooleanField(default=False)),
                 ('is_active', models.BooleanField(default=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('deleted_at', models.DateTimeField(blank=True, null=True)),
             ],
             options={
                 'db_table': 'api_endpoints',
@@ -31,14 +35,38 @@ class Migration(migrations.Migration):
             name='APIService',
             fields=[
                 ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('name', models.CharField(max_length=200, unique=True)),
+                ('api_service_no', models.CharField(max_length=250)),
+                ('name', models.CharField(max_length=200)),
                 ('base_url', models.CharField(max_length=200)),
                 ('service_url', models.CharField(max_length=200)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('deleted_at', models.DateTimeField(blank=True, null=True)),
             ],
             options={
                 'db_table': 'api_services',
             },
         ),
+        migrations.CreateModel(
+            name='Application',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('application_no', models.CharField(max_length=250)),
+                ('name', models.CharField(max_length=200, unique=True)),
+                ('theme', models.IntegerField()),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('deleted_at', models.DateTimeField(blank=True, null=True)),
+            ],
+            options={
+                'db_table': 'application',
+            },
+        ),
+        migrations.AddField(
+            model_name='apiservice',
+            name='application',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.DO_NOTHING, to='api.Application'),
+        ),
         migrations.AddField(
             model_name='apiendpoint',
             name='service',

api/migrations/0002_auto_20190511_1315.py → api/migrations/0002_apiservice_service_token.py

-# Generated by Django 2.1.5 on 2019-05-11 13:15
+# Generated by Django 2.1.5 on 2019-05-15 14:22
 
 from django.db import migrations, models
-import django.db.models.deletion
 
 
 class Migration(migrations.Migration):
@@ -11,21 +10,10 @@ class Migration(migrations.Migration):
     ]
 
     operations = [
-        migrations.CreateModel(
-            name='Application',
-            fields=[
-                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('name', models.CharField(max_length=200, unique=True)),
-                ('theme', models.IntegerField()),
-            ],
-            options={
-                'db_table': 'application',
-            },
-        ),
         migrations.AddField(
             model_name='apiservice',
-            name='application',
-            field=models.ForeignKey(default=1, on_delete=django.db.models.deletion.DO_NOTHING, to='api.Application'),
+            name='service_token',
+            field=models.CharField(default=1, max_length=200, unique=True),
             preserve_default=False,
         ),
     ]

api/migrations/0003_application_code.py

+# Generated by Django 2.1.5 on 2019-05-16 16:47
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('api', '0002_apiservice_service_token'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='application',
+            name='code',
+            field=models.CharField(default=1, max_length=300),
+            preserve_default=False,
+        ),
+    ]

api/models.py

 from django.db import models
+from django.utils import timezone
 
 
 class Application(models.Model):
+    application_no = models.CharField(max_length=250) 
     name = models.CharField(max_length=200, unique=True)
     theme = models.IntegerField()
+    code = models.CharField(max_length=300)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    deleted_at = models.DateTimeField(null=True, blank=True)
 
+    def delete(self):
+        self.deleted_at = timezone.now()
+        self.save()
+    
     def __str__(self):
         return self.name
 
@@ -13,10 +23,19 @@ class Application(models.Model):
 
 
 class APIService(models.Model):
-    name = models.CharField(max_length=200, unique=True)
+    api_service_no = models.CharField(max_length=250)
+    name = models.CharField(max_length=200)
+    service_token = models.CharField(max_length=200, unique=True)
     base_url = models.CharField(max_length=200)
     service_url = models.CharField(max_length=200)
     application = models.ForeignKey(Application, on_delete=models.DO_NOTHING)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    deleted_at = models.DateTimeField(null=True, blank=True)
+
+    def delete(self):
+        self.deleted_at = timezone.now()
+        self.save()
 
     def __str__(self):
         return self.name
@@ -26,14 +45,22 @@ class APIService(models.Model):
 
 
 class APIEndpoint(models.Model):
+    api_endpoint_no = models.CharField(max_length=250)
     service = models.ForeignKey(APIService, on_delete=models.DO_NOTHING)
-    name = models.CharField(max_length=200, unique=True)
+    name = models.CharField(max_length=200)
     description = models.CharField(max_length=255, null=True, blank=True)
     http_method = models.CharField(max_length=100)
     endpoint_url = models.CharField(max_length=200)
     is_need_auth = models.BooleanField(default=False)
     is_active = models.BooleanField(default=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    deleted_at = models.DateTimeField(null=True, blank=True)
 
+    def delete(self):
+        self.deleted_at = timezone.now()
+        self.save()
+        
     def __str__(self):
         return self.name
 

api/serializers.py

+import requests
 from rest_framework import serializers
 from .models import APIService, APIEndpoint, Application
+from api.utils import BadRequestException, number_generator
+from rest_framework.exceptions import ValidationError
+from django.utils.crypto import get_random_string
+from django.conf import settings
+
+ACCOUNT_GROUP = settings.ACCOUNT_GROUP
 
 
 class ApplicationSerializer(serializers.ModelSerializer):
+    groups = serializers.ListField(read_only=True)
+    modules = serializers.ListField(read_only=True)
+
+    def to_representation(self, data):
+        ids = data.id
+        req = requests.get(f'{ACCOUNT_GROUP}/{ids}/')
+        groups = req.json()['groups']
+        modules = req.json()['modules']
+
+        setattr(data, 'groups', groups)
+        setattr(data, 'modules', modules)
+
+        return super().to_representation(data)
+
     class Meta:
         model = Application
-        fields = ("id", "name", "theme")
+        fields = ('id', 'application_no', 'name', 'theme', 'groups', 'modules')
+        read_only_fields = (
+            'id', 'application_no', 'created_at', 'updated_at', 'deleted_at'
+        )
+
+    def is_valid(self, raise_exception=False):
+
+        assert not hasattr(self, 'restore_object'), (
+            'Serializer `%s.%s` has old-style version 2 `.restore_object()` '
+            'that is no longer compatible with REST framework 3. '
+            'Use the new-style `.create()` and `.update()` methods instead.' %
+            (self.__class__.__module__, self.__class__.__name__)
+        )
+
+        assert hasattr(self, 'initial_data'), (
+            'Cannot call `.is_valid()` as no `data=` keyword argument was '
+            'passed when instantiating the serializer instance.'
+        )
+
+        if not hasattr(self, '_validated_data'):
+            try:
+                self._validated_data = self.run_validation(self.initial_data)
+            except ValidationError as exc:
+                self._validated_data = {}
+                self._errors = exc.detail
+            else:
+                self._errors = {}
+
+        #if validation failed
+        if self._errors and raise_exception:
+            error_message = {}
+            message = str(self.errors)
+
+            for k, v in self.errors.items():
+                message = str(v)
+                start = message.find('string=') + 8
+                end = message.find(', code=') - 1
+                message = message[start:end]
+
+                error_message[str(k)] = message
+
+            raise BadRequestException(error_message)
+
+        return not bool(self._errors)
+
+    def create(self, validated_data):
+
+        new_application = Application.objects.create(**validated_data)
+        new_application.application_no = number_generator('APP', new_application.id)
+        new_application.save()
+        return new_application
 
 
 class APIServiceSerializer(serializers.ModelSerializer):
     class Meta:
         model = APIService
-        fields = ('id', 'name', 'base_url', 'service_url', 'application')
+        fields = ('id', 'api_service_no', 'name', 'service_token', 'base_url', 'service_url', 'application', 'created_at', 'updated_at', 'deleted_at')
+        read_only_fields = ('id', 'api_service_no', 'service_token', 'created_at', 'updated_at', 'deleted_at')
+
+    def is_valid(self, raise_exception=False):
+
+        assert not hasattr(self, 'restore_object'), (
+            'Serializer `%s.%s` has old-style version 2 `.restore_object()` '
+            'that is no longer compatible with REST framework 3. '
+            'Use the new-style `.create()` and `.update()` methods instead.' %
+            (self.__class__.__module__, self.__class__.__name__)
+        )
+
+        assert hasattr(self, 'initial_data'), (
+            'Cannot call `.is_valid()` as no `data=` keyword argument was '
+            'passed when instantiating the serializer instance.'
+        )
+
+        if not hasattr(self, '_validated_data'):
+            try:
+                self._validated_data = self.run_validation(self.initial_data)
+            except ValidationError as exc:
+                self._validated_data = {}
+                self._errors = exc.detail
+            else:
+                self._errors = {}
+
+        #if validation failed
+        if self._errors and raise_exception:
+            error_message = {}
+            message = str(self.errors)
+
+            for k, v in self.errors.items():
+                message = str(v)
+                start = message.find('string=') + 8
+                end = message.find(', code=') - 1
+                message = message[start:end]
+
+                error_message[str(k)] = message
+
+            raise BadRequestException(error_message)
+
+        return not bool(self._errors)
+
+    def create(self, validated_data):
+        new_service = APIService.objects.create(**validated_data)
+        new_service.api_service_no = number_generator('SVC', new_service.id)
+        new_service.service_token = get_random_string(length=16)
+        new_service.save()
+        return new_service
 
 
 class APIEndpointSerializer(serializers.ModelSerializer):
@@ -20,6 +139,53 @@ class APIEndpointSerializer(serializers.ModelSerializer):
     class Meta:
         model = APIEndpoint
         fields = (
-            'id', 'service', 'service_name', 'name', 'description',
-            'http_method', 'endpoint_url', 'is_need_auth', 'is_active'
+            'id', 'api_endpoint_no', 'service', 'service_name', 'name', 'description',
+            'http_method', 'endpoint_url', 'is_need_auth', 'is_active', 'created_at', 'updated_at', 'deleted_at'
         )
+        read_only_fields = ('id', 'api_endpoint_no', 'created_at', 'updated_at', 'deleted_at')
+
+    def is_valid(self, raise_exception=False):
+
+        assert not hasattr(self, 'restore_object'), (
+            'Serializer `%s.%s` has old-style version 2 `.restore_object()` '
+            'that is no longer compatible with REST framework 3. '
+            'Use the new-style `.create()` and `.update()` methods instead.' %
+            (self.__class__.__module__, self.__class__.__name__)
+        )
+
+        assert hasattr(self, 'initial_data'), (
+            'Cannot call `.is_valid()` as no `data=` keyword argument was '
+            'passed when instantiating the serializer instance.'
+        )
+
+        if not hasattr(self, '_validated_data'):
+            try:
+                self._validated_data = self.run_validation(self.initial_data)
+            except ValidationError as exc:
+                self._validated_data = {}
+                self._errors = exc.detail
+            else:
+                self._errors = {}
+
+        #if validation failed
+        if self._errors and raise_exception:
+            error_message = {}
+            message = str(self.errors)
+
+            for k, v in self.errors.items():
+                message = str(v)
+                start = message.find('string=') + 8
+                end = message.find(', code=') - 1
+                message = message[start:end]
+
+                error_message[str(k)] = message
+
+            raise BadRequestException(error_message)
+
+        return not bool(self._errors)
+
+    def create(self, validated_data):
+        new_endpoint = APIEndpoint.objects.create(**validated_data)
+        new_endpoint.api_endpoint_no = number_generator('ENP', new_endpoint.id)
+        new_endpoint.save()
+        return new_endpoint

api/urls.py

+from api.viewsets.applications import ApplicationViewSet
+from api.viewsets.services import  APIServiceViewSet
+from api.viewsets.endpoints import  APIEndpointViewSet
 from django.urls import path, include
 from rest_framework.routers import DefaultRouter, SimpleRouter
 from api.views import (
-    APIServiceViewSet, APIEndpointViewSet, ApplicationViewSet,
     APIGatewayList, APIGatewaySlugDetail, APIGatewaySlugModelDetail
 )
 
 router = DefaultRouter()
-router.register(r'api-applications', ApplicationViewSet)
-router.register(r'api-services', APIServiceViewSet)
-router.register(r'api-endpoint', APIEndpointViewSet)
+router.register(r'applications', ApplicationViewSet)
+router.register(r'services', APIServiceViewSet)
+router.register(r'endpoint', APIEndpointViewSet)
 
 urlpatterns = [
     path('', include(router.urls)),

api/utils.py

@@ -6,10 +6,16 @@ from rest_framework import status
 from django_filters import FilterSet
 from django_filters import rest_framework as filters
 from .models import APIEndpoint
+from rest_framework.pagination import PageNumberPagination
+from rest_framework.response import Response
+import datetime
 
-VALIDATE_TOKEN_URL = settings.VALIDATE_TOKEN_URL
 
+VALIDATE_TOKEN_URL = settings.VALIDATE_TOKEN_URL
 
+class BadRequestException(Exception):
+    pass 
+    
 class APIEndpointFilter(FilterSet):
     service = filters.CharFilter('service__name')
 
@@ -116,3 +122,40 @@ class Helper:
             return self._response_data({'message': str(e)},
                                        status.HTTP_500_INTERNAL_SERVER_ERROR,
                                        self._headers)
+
+class CustomPagination(PageNumberPagination):
+    page_size = 5 # Set number of result to display per page
+    max_page_size = 50  # Sets max page size that user may request
+    page_query_param = 'page'
+    page_size_query_param = 'page_size'
+
+    def get_paginated_response(self, data):
+        return Response({
+            'page_number': self.page.number,
+            'size_per_page': self.page.paginator.per_page,
+            'total_pages': self.page.paginator.num_pages,
+            'total': self.page.paginator.count,
+            'code': data['code'],
+            'status': data['status'],
+            'message': data['message'],
+            'results': data['results']
+        })
+
+# autogenerated number
+def number_generator(prefix, id):
+    date = '{:%Y%m%d}'.format(datetime.datetime.now())
+    id_num = '{:07}'.format(id)
+    autogenerated_no = prefix + '-' + date + '-' + id_num
+
+    return autogenerated_no
+
+# status message
+def status_message_response(code, status, message, results):
+    message = {
+            'code': code,
+            'status': status,
+            'message': message,
+            'results': results
+        }
+    return message
+

api/views.py

@@ -4,53 +4,7 @@ from rest_framework.decorators import action
 from rest_framework.response import Response
 from django_filters.rest_framework import DjangoFilterBackend
 from .models import APIService, APIEndpoint, Application
-from .serializers import (
-    APIServiceSerializer, APIEndpointSerializer, ApplicationSerializer
-)
-from .utils import APIEndpointFilter, Helper
-
-
-class ApplicationViewSet(viewsets.ModelViewSet):
-    http_method_names = [
-        'get', 'post', 'put', 'patch', 'head', 'options', 'trace'
-    ]
-    lookup_field = 'id'
-    queryset = Application.objects.all()
-    serializer_class = ApplicationSerializer
-
-    @action(methods=['GET'], detail=True)
-    def services(self, request, id=None):
-        app = self.get_object()
-        services = APIService.objects.filter(application=app)
-        serializer = APIServiceSerializer(services, many=True)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-
-class APIServiceViewSet(viewsets.ModelViewSet):
-    http_method_names = [
-        'get', 'post', 'put', 'patch', 'head', 'options', 'trace'
-    ]
-    queryset = APIService.objects.all()
-    serializer_class = APIServiceSerializer
-    lookup_field = 'id'
-
-    @action(methods=["GET"], detail=True)
-    def endpoints(self, request, id=None):
-        service = self.get_object()
-        endpoints = APIEndpoint.objects.filter(service=service)
-        serializer = APIEndpointSerializer(endpoints, many=True)
-        return Response(serializer.data, status=status.HTTP_200_OK)
-
-
-class APIEndpointViewSet(viewsets.ModelViewSet):
-    http_method_names = [
-        'get', 'post', 'put', 'patch', 'head', 'options', 'trace'
-    ]
-    queryset = APIEndpoint.objects.all().order_by('service')
-    serializer_class = APIEndpointSerializer
-    lookup_field = 'id'
-    filter_backends = (DjangoFilterBackend, )
-    filter_class = APIEndpointFilter
+from .utils import (APIEndpointFilter, Helper)
 
 
 class APIGatewayList(APIView):

api/viewsets/applications.py

+import requests
+from django.db.models import F
+from django.db.models import OuterRef, Subquery
+from django.conf import settings
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from api.models import Application
+from api.serializers import ApplicationSerializer
+from api.utils import (CustomPagination, BadRequestException,
+                       status_message_response)
+
+
+ACCOUNT_GROUP = settings.ACCOUNT_GROUP
+
+
+class ApplicationViewSet(viewsets.ModelViewSet):
+    http_method_names = [
+        'get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'
+    ]
+    lookup_field = 'pk'
+    queryset = Application.objects.all()
+    serializer_class = ApplicationSerializer
+    pagination_class = CustomPagination
+
+    # CREATE Application
+    def create(self, request, *args, **kwargs):
+        try:
+            serializer = self.get_serializer(data=request.data)
+            serializer.is_valid(raise_exception=True)
+            self.perform_create(serializer)
+            headers = self.get_success_headers(serializer.data)
+
+            message = status_message_response(
+                            201, 'success',
+                            'New application created', serializer.data
+                        )
+            return Response(message)
+
+        except BadRequestException as e:
+            message = status_message_response(400, 'failed', str(e), [])
+            return Response(message, status=status.HTTP_400_BAD_REQUEST)
+
+        except Exception as e:
+            message = status_message_response(
+                            500, 'failed',
+                            'Request was not able to process' + str(e), []
+                        )
+            return Response(message,
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    # SHOW LIST of Applications
+    def list(self, request, *args, **kwargs):
+        try:
+            queryset = Application.objects.filter(deleted_at__exact=None)
+            if not queryset.exists():
+                message = status_message_response(
+                    200, 'success', 'No records found', []
+                )
+                return Response(message)
+
+            page = self.paginate_queryset(queryset)
+            if page is not None:
+                serializer = self.get_serializer(page, many=True)
+                message = {
+                    'code': 200,
+                    'status': 'success',
+                    'message': 'List of applications found',
+                    'results': serializer.data
+                }
+                return self.get_paginated_response(message)
+
+        except Exception as e:
+            message = status_message_response(
+                500, 'failed',
+                'Request was not able to process' + str(e), [])
+            return Response(message,
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    # SHOW application details
+    def retrieve(self, request, *args, **kwargs):
+        try:
+            id = self.kwargs['pk']
+            queryset = Application.objects.filter(id=id)
+            serializer = self.get_serializer(queryset, many=True)
+
+            if not queryset.exists():
+                message = status_message_response(404, 'failed',
+                                                  'No record found', [])
+                return Response(message, status=status.HTTP_404_NOT_FOUND)
+            else:
+                message = status_message_response(
+                            200, 'success',
+                            'Application retrieved', serializer.data
+                          )
+                return Response(message, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            message = status_message_response(
+                            500, 'failed',
+                            'Request was not able to process' + str(e), []
+                        )
+            return Response(message,
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    # UPDATE Application
+    def update(self, request, *args, **kwargs):
+        try:
+            partial = kwargs.pop('partial', False)
+            instance = self.get_object()
+            serializer = self.get_serializer(instance, data=request.data,
+                                             partial=partial)
+            serializer.is_valid(raise_exception=True)
+            self.perform_update(serializer)
+            if getattr(instance, '_prefetched_objects_cache', None):
+                instance._prefetched_objects_cache = {}
+
+            message = status_message_response(
+                            200, 'success', 'Application updated',
+                            serializer.data
+                        )
+            return Response(message)
+
+        except Exception as e:
+            message = status_message_response(
+                            500, 'failed',
+                            'Request was not able to process' + str(e), []
+                        )
+            return Response(message,
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    # SOFT DELETE / ARCHIVED
+    def destroy(self, request, *args, **kwargs):
+        try:
+            instance = self.get_object()
+            self.perform_destroy(instance)
+
+            message = status_message_response(
+                            200, 'success', 'Application deleted', []
+                        )
+            return Response(message, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            message = status_message_response(
+                            500, 'failed',
+                            'Request was not able to process' + str(e), []
+                        )
+            return Response(message,
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+    # PATCH - RESTORE archived application
+    def partial_update(self, request, *args, **kwargs):
+        try:
+            kwargs['partial'] = True
+            instance = self.get_object()
+            instance.deleted_at = None
+            serializer = self.get_serializer(instance)
+            message = status_message_response(
+                            200, 'success',
+                            'Archived application restored', serializer.data
+                        )
+            instance.save()
+            return Response(message)
+
+        except Exception as e:
+            message = status_message_response(
+                            500, 'failed',
+                            'Request was not able to process' + str(e), []
+                        )
+            return Response(message,
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+    # /archived - show list of archived application
+    @action(methods=["GET"], detail=False)
+    def archived(self, request, pk=None):
+        try:
+            queryset = Application.objects.filter(deleted_at__isnull=False)
+
+            if not queryset.exists():
+                message = status_message_response(
+                                200, 'success',
+                                'No archived applications', []
+                            )
+                return Response(message)
+
+            page = self.paginate_queryset(queryset)
+            if page is not None:
+                serializer = self.get_serializer(page, many=True)
+                message = {
+                    'code': 200,
+                    'status': 'success',
+                    'message': 'Archived applications found',
+                    'results': serializer.data
+                }
+                return self.get_paginated_response(message)
+
+        except Exception as e:
+            message = status_message_response(
+                            500, 'failed',
+                            'Request was not able to process' + str(e), []
+                        )
+            return Response(message,
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    # Show app services
+    @action(methods=['GET'], detail=True)
+    def services(self, request, pk):
+        try:
+            services = APIService.objects.filter(application=pk)
+
+            page = self.paginate_queryset(services)
+            if page is not None:
+                serializer = APIServiceSerializer(page, many=True)
+                message = {
+                    'code': 200,
+                    'status': 'success',
+                    'message': 'Application services found',
+                    'results': serializer.data
+                }
+                return self.get_paginated_response(message)
+
+        except Exception as e:
+            message = status_message_response(
+                            500, 'failed',
+                            'Request was not able to process' + str(e), []
+                        )
+            return Response(message,
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)

api/viewsets/endpoints.py

+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from api.models import APIEndpoint
+from api.serializers import APIEndpointSerializer
+from api.utils import (APIEndpointFilter, CustomPagination, BadRequestException, status_message_response)
+from django_filters.rest_framework import DjangoFilterBackend
+
+
+class APIEndpointViewSet(viewsets.ModelViewSet):
+    http_method_names = [
+        'get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'
+    ]
+    queryset = APIEndpoint.objects.all().order_by('service')
+    serializer_class = APIEndpointSerializer
+    lookup_field = 'pk'
+    filter_backends = (DjangoFilterBackend, )
+    filter_class = APIEndpointFilter
+    pagination_class = CustomPagination
+
+    # CREATE Endpoint
+    def create(self, request, *args, **kwargs):
+        try:
+            serializer = self.get_serializer(data=request.data)
+            serializer.is_valid(raise_exception=True)
+            self.perform_create(serializer)
+            headers = self.get_success_headers(serializer.data)
+
+            message = status_message_response(201, 'success', 'New endpoint created', serializer.data)
+            return Response(message)
+        
+        except BadRequestException as e:
+            message = status_message_response(400, 'failed', str(e), [])
+            return Response(message, status=status.HTTP_400_BAD_REQUEST)
+
+        except Exception as e:
+            message = status_message_response(500, 'failed', 'Request was not able to process' + str(e), [])
+            return Response(message, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    # SHOW LIST of endpoints
+    def list(self, request, *args, **kwargs):
+        try:
+            queryset = APIEndpoint.objects.filter(deleted_at__exact=None)
+
+            if not queryset.exists():
+                message = status_message_response(200, 'success', 'No records found', [])
+                return Response(message)
+                
+            page = self.paginate_queryset(queryset)
+            if page is not None:
+                serializer = self.get_serializer(page, many=True)
+                message = {
+                    'code': 200,
+                    'status': 'success',
+                    'message': 'List of endpoints found',
+                    'results': serializer.data
+                }
+                return self.get_paginated_response(message)
+
+        except Exception as e:
+            message = status_message_response(500, 'failed', 'Request was not able to process' + str(e), [])
+            return Response(message, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    # SHOW endpoint details
+    def retrieve(self, request, *args, **kwargs):
+        try:
+            id = self.kwargs['pk']
+            queryset = APIEndpoint.objects.filter(id=id)
+            serializer = self.get_serializer(queryset, many=True)
+            
+            if not queryset.exists():
+                message = status_message_response(404, 'failed', 'No record found', [])
+                return Response(message, status=status.HTTP_404_NOT_FOUND)
+            else:
+                message = status_message_response(200, 'success', 'Endpoint retrieved', serializer.data)
+                return Response(message, status=status.HTTP_200_OK)
+        
+        except Exception as e:
+            message = status_message_response(500, 'failed', 'Request was not able to process' + str(e), [])
+            return Response(message, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    # UPDATE endpoint
+    def update(self, request, *args, **kwargs):
+        try:
+            partial = kwargs.pop('partial', False)
+            instance = self.get_object()
+            serializer = self.get_serializer(instance, data=request.data, partial=partial)
+            serializer.is_valid(raise_exception=True)
+            self.perform_update(serializer)
+            if getattr(instance, '_prefetched_objects_cache', None):
+                instance._prefetched_objects_cache = {}
+            
+            message = status_message_response(200, 'success', 'Endpoint updated', serializer.data)
+            return Response(message)
+        
+        except Exception as e:
+            message = status_message_response(500, 'failed', 'Request was not able to process' + str(e), [])
+            return Response(message, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    # SOFT DELETE / ARCHIVED
+    def destroy(self, request, *args, **kwargs):
+        try:
+            instance = self.get_object()
+            self.perform_destroy(instance)
+            
+            message = status_message_response(200, 'success', 'Endpoint deleted', [])
+            return Response(message, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            message = status_message_response(500, 'failed', 'Request was not able to process' + str(e), [])
+            return Response(message, status=status.HTTP_500_INTERNAL_SERVER_ERROR)            
+
+
+    # PATCH - RESTORE archived endpoint
+    def partial_update(self, request, *args, **kwargs):
+        try:
+            kwargs['partial'] = True
+            instance = self.get_object()
+            instance.deleted_at = None
+            serializer = self.get_serializer(instance)
+            message = status_message_response(200, 'success', 'Archived endpoint restored', serializer.data)
+            instance.save()
+            return Response(message)
+
+        except Exception as e:
+            message = status_message_response(500, 'failed', 'Request was not able to process' + str(e), [])
+            return Response(message, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+        
+
+    # /archived - show list of archived endpoints
+    @action(methods=["GET"], detail=False)
+    def archived(self, request, pk=None):
+        try:
+            queryset = APIEndpoint.objects.filter(deleted_at__isnull=False)
+            
+            if not queryset.exists():
+                message = status_message_response(200, 'success', 'No archived endpoints', [])
+                return Response(message)
+
+            page = self.paginate_queryset(queryset)
+            if page is not None:
+                serializer = self.get_serializer(page, many=True)
+                message = {
+                    'code': 200,
+                    'status': 'success',
+                    'message': 'Archived endpoints found',
+                    'results': serializer.data
+                }
+                return self.get_paginated_response(message)
+
+        except Exception as e:
+            message = status_message_response(500, 'failed', 'Request was not able to process' + str(e), [])
+            return Response(message, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

api/viewsets/services.py

+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from api.models import APIService
+from api.serializers import APIServiceSerializer
+from api.utils import (CustomPagination, BadRequestException, status_message_response)
+
+
+class APIServiceViewSet(viewsets.ModelViewSet):
+    http_method_names = [
+        'get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'
+    ]
+    queryset = APIService.objects.all()
+    serializer_class = APIServiceSerializer
+    lookup_field = 'pk'
+    pagination_class = CustomPagination
+
+    # CREATE Service
+    def create(self, request, *args, **kwargs):
+        try:
+            serializer = self.get_serializer(data=request.data)
+            serializer.is_valid(raise_exception=True)
+            self.perform_create(serializer)
+            headers = self.get_success_headers(serializer.data)
+
+            message = status_message_response(201, 'success', 'New service created', serializer.data)
+            return Response(message)
+        
+        except BadRequestException as e:
+            message = status_message_response(400, 'failed', str(e), [])
+            return Response(message, status=status.HTTP_400_BAD_REQUEST)
+
+        except Exception as e:
+            message = status_message_response(500, 'failed', 'Request was not able to process' + str(e), [])
+            return Response(message, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    # SHOW LIST of services
+    def list(self, request, *args, **kwargs):
+        try:
+            queryset = APIService.objects.filter(deleted_at__exact=None)
+
+            if not queryset.exists():
+                message = status_message_response(200, 'success', 'No records found', [])
+                return Response(message)
+                
+            page = self.paginate_queryset(queryset)
+            if page is not None:
+                serializer = self.get_serializer(page, many=True)
+                message = {
+                    'code': 200,
+                    'status': 'success',
+                    'message': 'List of services found',
+                    'results': serializer.data
+                }
+                return self.get_paginated_response(message)
+
+        except Exception as e:
+            message = status_message_response(500, 'failed', 'Request was not able to process' + str(e), [])
+            return Response(message, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    # SHOW service details
+    def retrieve(self, request, *args, **kwargs):
+        try:
+            id = self.kwargs['pk']
+            queryset = APIService.objects.filter(id=id)
+            serializer = self.get_serializer(queryset, many=True)
+
+            if not queryset.exists():
+                message = status_message_response(404, 'failed', 'No record found', [])
+                return Response(message, status=status.HTTP_404_NOT_FOUND)
+            else:
+                message = status_message_response(200, 'success', 'Service retrieved', serializer.data)
+                return Response(message, status=status.HTTP_200_OK)
+        
+        except Exception as e:
+            message = status_message_response(500, 'failed', 'Request was not able to process' + str(e), [])
+            return Response(message, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    # UPDATE service
+    def update(self, request, *args, **kwargs):
+        try:
+            partial = kwargs.pop('partial', False)
+            instance = self.get_object()
+            serializer = self.get_serializer(instance, data=request.data, partial=partial)
+            serializer.is_valid(raise_exception=True)
+            self.perform_update(serializer)
+            if getattr(instance, '_prefetched_objects_cache', None):
+                instance._prefetched_objects_cache = {}
+            
+            message = status_message_response(200, 'success', 'Service updated', serializer.data)
+            return Response(message)
+        
+        except Exception as e:
+            message = status_message_response(500, 'failed', 'Request was not able to process' + str(e), [])
+            return Response(message, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    # SOFT DELETE / ARCHIVED
+    def destroy(self, request, *args, **kwargs):
+        try:
+            instance = self.get_object()
+            self.perform_destroy(instance)
+
+            message = status_message_response(200, 'success', 'Service deleted', [])
+            return Response(message, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            message = status_message_response(500, 'failed', 'Request was not able to process' + str(e), [])
+            return Response(message, status=status.HTTP_500_INTERNAL_SERVER_ERROR)            
+
+
+    # PATCH - RESTORE archived service
+    def partial_update(self, request, *args, **kwargs):
+        try:
+            kwargs['partial'] = True
+            instance = self.get_object()
+            instance.deleted_at = None
+            serializer = self.get_serializer(instance)
+            message = status_message_response(200, 'success', 'Archived service restored', serializer.data)
+            instance.save()
+            return Response(message)
+
+        except Exception as e:
+            message = status_message_response(500, 'failed', 'Request was not able to process' + str(e), [])
+            return Response(message, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+        
+
+    # /archived - show list of archived services
+    @action(methods=["GET"], detail=False)
+    def archived(self, request, pk=None):
+        try:
+            queryset = APIService.objects.filter(deleted_at__isnull=False)
+            
+            if not queryset.exists():
+                message = status_message_response(200, 'success', 'No archived services', [])
+                return Response(message)
+
+            page = self.paginate_queryset(queryset)
+            if page is not None:
+                serializer = self.get_serializer(page, many=True)
+                message = {
+                    'code': 200,
+                    'status': 'success',
+                    'message': 'Archived services found',
+                    'results': serializer.data
+                }
+                return self.get_paginated_response(message)
+
+        except Exception as e:
+            message = status_message_response(500, 'failed', 'Request was not able to process' + str(e), [])
+            return Response(message, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    # Show service endpoints
+    @action(methods=['GET'], detail=True)
+    def endpoints(self, request, pk):
+        try:
+            endpoints = APIEndpoint.objects.filter(service=pk)
+            
+            page = self.paginate_queryset(endpoints)
+            if page is not None:
+                serializer = APIEndpointSerializer(page, many=True)
+                message = {
+                    'code': 200,
+                    'status': 'success',
+                    'message': 'Service endpoints found',
+                    'results': serializer.data
+                }
+                return self.get_paginated_response(message)
+
+        except Exception as e:
+            message = status_message_response(500, 'failed', 'Request was not able to process' + str(e), [])
+            return Response(message, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

config/settings/local.py

@@ -33,3 +33,4 @@ AUTHENTICATOR_IP = config['SERVICE']['AUTHENTICATOR_IP']
 AUTHENTICATOR_PATH = '/api/v1/authenticator'
 
 VALIDATE_TOKEN_URL = f'http://{AUTHENTICATOR_IP}{AUTHENTICATOR_PATH}/validate-token/'
+ACCOUNT_GROUP = f'http://{AUTHENTICATOR_IP}{AUTHENTICATOR_PATH}/account-dependent'