Merge branch 'dev_branch' into 'master'

Dev branch

See merge request red/red-ci-cd!27

.env

+export=9000
+local=8000
\ No newline at end of file

.gitignore

+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+env.ini
+media/
+.media
+media
+
+docker-compose.yml
+Dockerfile
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+*.sh
+
+# Django stuff:
+*.log
+local_*.py
+
+# virtualenv
+.venv
+venv/
+ENV/
+
+#vscode
+.vscode/

.gitlab-ci.yml

-stages: 
-    - build 
+# include:
+#   - remote: 'http://tir:Qwerty1234@54.169.104.100:27015/red/red-ci-cd/blob/dev_branch/dev_deploy.gitlab-ci.yml'
+#   - remote: 'http://tir:Qwerty1234@54.169.104.100:27015/red/red-ci-cd/blob/dev_branch/redeploy.gitlab-ci.yml'
 
-build api: 
-    stage: build
-    image: ubuntu
-    before_script:
-        - 'which ssh-agent || ( apt-get update -y && apt-get install openssh-client -y )'
-        - eval $(ssh-agent -s)
-        - mkdir -p ~/.ssh
-        - chmod 700 ~/.ssh
-        - echo "$CENTOS_SERVER" | ssh-add - > ~/.ssh/id_rsa
-        - '[[ -f /.dockerenv ]] && echo -e "Host *\n\tStrictHostKeyChecking no\n\n" > ~/.ssh/config'
-        - apt-get install git-core -y
-        - ssh -tt centos@13.251.192.208 "sudo mkdir /var/www/testred"
-        - ssh -tt centos@13.251.192.208 "cd /var/www/testred && sudo git clone http://tir:Qwerty1234@54.169.104.100:27015/rms/Backend/api-main-service.git -b $backend"
-        - ssh -tt centos@13.251.192.208 "sudo cp /var/www/testred/api-main-service/docker-compose.yml.template /var/www/testred/api-main-service/docker-compose.yml"
-        - ssh -tt centos@13.251.192.208 "sudo cp /var/www/testred/api-main-service/Dockerfile.template /var/www/testred/api-main-service/Dockerfile"
-        - ssh -tt centos@13.251.192.208 "sudo cp /var/www/testred/api-main-service/env.new_template.ini /var/www/testred/api-main-service/env.ini"
-        - ssh -tt centos@13.251.192.208 "sudo cp /var/www/testred/api-main-service/full-api-redeploy.sh.template.SIT /var/www/testred/api-main-service/full-api-redeploy.sh"
-        - ssh -tt centos@13.251.192.208 "sudo cp /var/www/testred/api-main-service/redtest.conf /etc/nginx/sites-enabled/redtest.conf"
-        - ssh -tt centos@13.251.192.208 "sudo sh /var/www/testred/api-main-service/full-api-redeploy.sh"
-    variables:
-      GIT_STRATEGY: clone
-      GIT_DEPTH: "3600"
-    script: 
-        - git branch    
-    
-    
-build web: 
-    stage: build
-    image: ubuntu
-    before_script:
-        - 'which ssh-agent || ( apt-get update -y && apt-get install openssh-client -y )'
-        - eval $(ssh-agent -s)
-        - mkdir -p ~/.ssh
-        - chmod 700 ~/.ssh
-        - echo "$CENTOS_SERVER" | ssh-add - > ~/.ssh/id_rsa
-        - '[[ -f /.dockerenv ]] && echo -e "Host *\n\tStrictHostKeyChecking no\n\n" > ~/.ssh/config'
-        - apt-get install git-core -y
-        - ssh -tt centos@13.251.192.208 "cd /var/www/testred && sudo git clone http://tir:Qwerty1234@54.169.104.100:27015/rms/frontend/web.git -b $frontend"
-        - ssh -tt centos@13.251.192.208 "sudo cp /var/www/testred/web/docker-compose.yml.template /var/www/testred/web/docker-compose.yml"
-        - ssh -tt centos@13.251.192.208 "sudo cp /var/www/testred/web/Dockerfile.template /var/www/testred/web/Dockerfile"
-        - ssh -tt centos@13.251.192.208 "sudo cp /var/www/testred/web/nuxt.env.json.demo.template /var/www/testred/web/nuxt.env.json"
-        - ssh -tt centos@13.251.192.208 "sudo cp /var/www/testred/web/full-api-redeploy.sh.template /var/www/testred/web/full-api-redeploy.sh"
-        - ssh -tt centos@13.251.192.208 "sudo cp /var/www/testred/web/redtestWeb.conf /etc/nginx/sites-enabled/redtestWeb.conf"
-        - ssh -tt centos@13.251.192.208 "sudo sh /var/www/testred/web/full-api-redeploy.sh"
-        - ssh -tt centos@13.251.192.208 "sudo systemctl restart nginx"
-    variables:
-      GIT_STRATEGY: clone
-      GIT_DEPTH: "3600"
-    script: 
-        - git branch
+stages:
+  - initial_repo
+  - clean_initial_repo
+#   - re-deploy-dev
+#   - clean_re-deploy-dev
+
+
+include:
+  - local: /red-ci-cd/dev_branch/dev_deploy.gitlab-ci.yml
\ No newline at end of file

01-bitbucket-pull-repository.sh.template.SIT

+set password "t!r\$0lut10ns"
+
+cd /var/www/devrms.oneberrysystem.com/api-main-service
+spawn git pull "http://administrator@42.61.118.105:7990/scm/rms/api-main-service.git" SIT
+expect "Password for"
+send "$password\n"

03-full-api-redeploy.sh.template.SIT

+echo "================================================================";
+echo "======================REMOVING API SERVICES=====================";
+
+docker-compose -f api-main-service/docker-compose.yml down
+
+echo "================================================================";
+
+
+cd /var/www/devrms.oneberrysystem.com/
+
+echo "================================================================";
+echo "======================BUILDING API SERVICES=====================";
+
+docker-compose -f api-main-service/docker-compose.yml up -d --build
+
+echo "================================================================";

Dockerfile.template

+FROM python:3.6
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+ADD . /code
+COPY . /code
+WORKDIR /code
+RUN pip install -r requirements/local.txt
+RUN python manage.py migrate

README.md

+# This is the repository for the Main service API
+
+## Working With Multiple Settings Modules
+
+You have to pass which settings.py module you want to use in the command line:
+```
+run the sqlfile at requirements folder.
+initial postman collection located at requirements folder.
+```
\ No newline at end of file

app/01-bitbucket-pull-repository.sh.template

+set password "t!r\$0lut10ns"
+
+cd /var/www/devrms.oneberrysystem.com/api-main-service
+spawn git pull "http://administrator@42.61.118.105:7990/scm/rms/api-main-service.git" staging
+expect "Password for"
+send "$password\n"
+interact

app/03-full-api-redeploy.sh.template

+echo "================================================================";
+echo "======================REMOVING API SERVICES=====================";
+
+docker-compose -f api-main-service/docker-compose.yml down
+
+echo "================================================================";
+
+
+cd /var/www/devrms.oneberrysystem.com/
+
+echo "================================================================";
+echo "======================BUILDING API SERVICES=====================";
+
+docker-compose -f api-main-service/docker-compose.yml up -d --build --remove-orphans
+
+echo "================================================================";

app/accesslayer/apps.py

+from django.apps import AppConfig
+
+
+class AccesslayerConfig(AppConfig):
+    name = 'accesslayer'

app/accesslayer/authentication.py

+from app.middleware.current_user.data import set_current_user
+from rest_framework.authentication import TokenAuthentication
+from rest_framework import exceptions
+from datetime import datetime, timedelta
+from django.conf import settings
+
+
+class AppTokenAuthentication(TokenAuthentication):
+    keyword = 'Bearer'
+    
+    def authenticate_credentials(self, key):
+
+        user, token = super(AppTokenAuthentication,
+                            self).authenticate_credentials(key)
+        
+        if token.created < datetime.now() - timedelta(minutes=int(settings.SESSION_TIMEOUT)):
+            token.delete()
+            raise exceptions.AuthenticationFailed('Token has expired')
+        else:
+            token.created = datetime.now()
+            token.save()
+
+        set_current_user(user)
+
+        return (user, token)

app/accesslayer/urls.py

+from django.urls import path, re_path
+
+from app.accesslayer import views
+
+urlpatterns = (
+    path(r'login/', views.Login.as_view(), name="API Login"),
+    re_path(r'^logout/', views.Logout.as_view(), name="API Logout"),
+    re_path(r'^refresh-token/(?P<token>\w+)/$', views.RefreshToken.as_view(), name="Refresh Token"),
+    path(r'current-user/', views.CurrentUser.as_view(), name="Current User"),
+
+    # re_path(r'^forgot-password/(?P<username>\w+)/$', views.ForgotPassword.as_view(), name="Forgot Password"),
+    # re_path(r'^validate-forgot-password-reset-token/(?P<token>\w+)/$', views.ValidateForgotPasswordResetToken.as_view(), name="Validate Forgot Password Reset Token"),
+    # re_path(r'^forgot-password-reset/(?P<token>\w+)/$', views.ForgotPasswordReset.as_view(), name="Forgot Password Reset"),
+
+    path('forgot-password/', views.ForgotPassword.as_view()),
+    path('reset-password-link/', views.ValidateForgotPasswordResetToken.as_view()),
+    path('forgot-password-reset/', views.ForgotPasswordReset.as_view()),
+)

app/accesslayer/views.py

+import json
+import threading
+from rest_framework import status
+from rest_framework.views import APIView
+from rest_framework.authtoken.views import ObtainAuthToken
+from rest_framework.authtoken.models import Token
+from rest_framework.response import Response
+from rest_framework.authentication import TokenAuthentication
+from rest_framework.permissions import AllowAny
+from django.db import transaction
+from app.helper import decorators
+from app.applicationlayer.management.account.serializer import (
+    UserManagementRetreiveSerializer
+)
+from app.entities.models import User, AuthToken
+from datetime import datetime
+from random import randrange
+from django.conf import settings
+from app.helper.email_service import sender
+from app.applicationlayer.utils import main_threading
+from rest_framework.exceptions import ParseError
+from datetime import timedelta
+
+
+class Login(ObtainAuthToken):
+    @decorators.error_safe
+    def post(self, request, *args, **kwargs):
+        try:
+            serializer = self.serializer_class(data=request.data,
+                                               context={'request': request})
+            serializer.is_valid(raise_exception=True)
+            user = serializer.validated_data['user']
+            token, created = Token.objects.get_or_create(user=user)
+
+            if not created:
+                token.created = datetime.now()
+                token.save()
+
+            return Response({
+                'token': token.key,
+            })
+        except Exception as e:
+            return Response(
+                {"message": "Unable to log in with provided credentials."}
+            )
+
+
+class Logout(APIView):
+    @decorators.error_safe
+    def post(self, request, *args, **kwargs):
+        existingUser = self.request.user
+        if existingUser:
+            existingToken = Token.objects.filter(user=existingUser).first()
+            if existingToken:
+                existingToken.delete()
+                return Response(data={"detail": "User was logged out"},
+                                status=status.HTTP_200_OK)
+            else:
+                return Response(data={"detail": "User session not found"},
+                                status=status.HTTP_404_NOT_FOUND)
+        else:
+            return Response(data={"detail": "User not found"},
+                            status=status.HTTP_404_NOT_FOUND)
+
+
+class RefreshToken(APIView):
+    @decorators.error_safe
+    def post(self, request, token=None, *args, **kwargs):
+        existingToken = Token.objects.filter(key=token).first()
+        if existingToken:
+            if existingToken.user == request.user:
+                existingToken.created = datetime.now()
+                existingToken.save()
+                return Response(data={"detail": "Token refreshed"},
+                                status=status.HTTP_200_OK)
+            else:
+                return Response(data={"detail": "Token user not match"},
+                                status=status.HTTP_401_UNAUTHORIZED)
+        else:
+            return Response(data={"detail": "Token not found"},
+                            status=status.HTTP_404_NOT_FOUND)
+
+
+class CurrentUser(APIView):
+    def get(self, request, token=None, *args, **kwargs):
+        serializer = UserManagementRetreiveSerializer
+        
+        context = {"request": request}
+        
+        serializer = serializer(request.user, context=context)
+        serializer.data['key'] = 'value'
+        serialized = serializer.data
+
+        return Response(data=serialized,
+                        status=status.HTTP_200_OK)
+
+
+'''
+***********************
+** RESET CREDENTIALS **
+***********************
+'''
+
+
+class ForgotPassword(APIView):
+    permission_classes = (AllowAny,)
+
+    @transaction.atomic
+    def post(self, request, *args, **kwargs):
+        email = request.data['email']
+        username = request.data['username']
+        try:
+            user = request.user.email
+        except Exception as e:
+            user = str(settings.CATCH_EMAIL)
+        
+        existingUser = User.objects.filter(
+            email=email,
+            username=username).first()
+        
+        date_now = datetime.now()
+        
+        if existingUser:
+            # Check if there's existing request
+            exToken = AuthToken\
+                      .objects\
+                      .filter(
+                          user=existingUser.code,
+                          is_active=True,
+                          timeout_at__lt=date_now)\
+                      .first()
+            
+            if exToken:
+                raise ParseError('There is an existing password reset for this user.')
+            
+            REF = 'AUTH'
+            TOKEN = ''
+            PASSCODE = 0
+
+            # Generate Random token for TOKEN
+            TOKEN = Token().generate_key()
+            
+            # Generate Random number for PASSCODE
+            rands = []
+            rands.append(randrange(10))
+            rands.append(randrange(10))
+            rands.append(randrange(10))
+            rands.append(randrange(10))
+            PASSCODE = f"{rands[0]}{rands[1]}{rands[2]}{rands[3]}"
+            
+            date_now = datetime.now()
+            timeout_at = date_now + timedelta(seconds=3600)
+
+            AuthToken(
+                ref=REF,
+                token=TOKEN,
+                passcode=PASSCODE,
+                is_active=True,
+                user=existingUser,
+                created=date_now,
+                timeout_at=timeout_at
+            ).save()
+            
+            url = f"{settings.FRONT_END_URL}/forgot-password/reset"\
+                  f"?token={TOKEN}"
+
+            args = [str(PASSCODE), str(url), user, str(existingUser.email),
+                    str(existingUser.name)]
+            
+            main_threading(args, sender.forgot_password)
+
+            return Response(data={"detail": "Forgot Password Sent"},
+                            status=status.HTTP_200_OK)
+        else:
+            return Response(data={"error": "User not found"},
+                            status=status.HTTP_404_NOT_FOUND)
+
+
+class ValidateForgotPasswordResetToken(APIView):
+    permission_classes = (AllowAny,)
+
+    @decorators.error_safe
+    @transaction.atomic
+    def post(self, request, *args, **kwargs):
+        token = request.data['token']
+        
+        date_now = datetime.now()
+        
+        existingToken = AuthToken.objects.filter(token=token).first()
+        if existingToken:
+            if not existingToken.is_active:
+                raise Exception('Request is no longer active')
+            elif existingToken.timeout_at < date_now:
+                raise Exception('Token already expired')
+            
+            return Response(data={
+                                "username": existingToken.user.username,
+                                "email": existingToken.user.email
+                            },
+                            status=status.HTTP_200_OK)
+        else:
+            return Response(data={"error": "Token not found"},
+                            status=status.HTTP_404_NOT_FOUND)
+
+
+class ForgotPasswordReset(APIView):
+    permission_classes = (AllowAny,)
+
+    @decorators.error_safe
+    @transaction.atomic
+    def post(self, request, *args, **kwargs):
+
+        body_unicode = request.body.decode('utf-8')
+        body_data = json.loads(body_unicode)
+
+        username = body_data['username']
+        password = body_data['password']
+        password_confirm = body_data['password_confirm']
+        passcode = body_data['passcode']
+        token = body_data['token']
+
+        if not username:
+            raise Exception('Username is required')
+
+        if not passcode:
+            raise Exception('Passcode is required')
+
+        if password != password_confirm:
+            raise Exception('Passwords must match')
+
+        existingToken = AuthToken.objects.filter(token=token).first()
+
+        if existingToken:
+
+            if existingToken.user.username != username:
+                raise Exception('Username does not match')
+
+            if not existingToken.is_active:
+                raise Exception('Request is no longer active')
+
+            if existingToken.passcode != passcode:
+                raise Exception('Invalid Passcode')
+
+            # TODO: Reset password here
+            exUser = User.objects.filter(id=existingToken.user.id).first()
+            exUser.set_password(password_confirm)
+            exUser.save()
+
+            existingToken.is_active = False
+            existingToken.save()
+
+            # sender.password_changed(
+            #     str(existingToken.user.username),
+            #     str(datetime.now()),
+            #     str(existingToken.user.email))
+
+            # args = [str(PASSCODE), str(url), str(existingUser.email), user]
+            # t1 = threading.Thread(target=sender.forgot_password, args=(args,))
+            # t1.start()
+
+            # args = [str(PASSCODE), str(url), user, str(existingUser.email)]
+            # t2 = threading.Thread(target=sender.forgot_password, args=(args,))
+            # t2.start()
+
+            return Response(data={"detail": "Forgot Password Reset Success"},
+                            status=status.HTTP_200_OK)
+        else:
+            return Response(data={"error": "Token not found"},
+                            status=status.HTTP_404_NOT_FOUND)

app/applicationlayer/ams/ams_privilege/serializer.py

+from rest_framework import serializers
+from app.entities.models import AMSPrivilege
+from app.applicationlayer.utils import model_to_dict
+
+
+class AMSPrivilegeSerializer(serializers.ModelSerializer):
+
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        ret['id_number'] = model_to_dict(instance.id_number)
+        ret['department'] = model_to_dict(instance.department)
+        ret['company'] = model_to_dict(instance.department.company)
+        ret['ams_user_type'] = instance.ams_user_type
+        return ret
+    
+    class Meta:
+        model = AMSPrivilege
+        fields = '__all__'
+

app/applicationlayer/ams/ams_privilege/table_filter.py

+from django_filters import rest_framework as filters
+from app.entities.models import AMSPrivilege
+from django.db.models import Q
+
+
+class AMSPrivilegeFilterSet(filters.FilterSet):
+    
+    class Meta:
+        model = AMSPrivilege
+        fields = '__all__'

app/applicationlayer/ams/ams_privilege/views.py

+from rest_framework import status, viewsets
+from rest_framework.response import Response
+from app.entities.models import AMSPrivilege
+from app.applicationlayer.utils import (CustomPagination,
+                                        status_message_response)
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.applicationlayer.ams.ams_privilege.serializer import (
+    AMSPrivilegeSerializer
+)
+from app.applicationlayer.ams.ams_privilege.table_filter import (
+    AMSPrivilegeFilterSet
+)
+from django.db import transaction
+from rest_framework.exceptions import ValidationError
+from django.db import IntegrityError
+
+
+class AMSPrivilegeViewSet(viewsets.ModelViewSet):
+    queryset = AMSPrivilege.objects.select_related(
+        'id_number', 'department'
+    ).all()
+    serializer_class = AMSPrivilegeSerializer
+    pagination_class = CustomPagination
+    lookup_field = 'id_number'
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = AMSPrivilegeFilterSet
+    ordering_fields = '__all__'
+    search_fields = (
+        'id_number__code',
+        'department__code',
+        'ams_user_type'
+    )
+    
+    def list(self, request, *args, **kwargs):
+        
+        queryset = self.filter_queryset(self.get_queryset())
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+            
+            message = status_message_response(
+                200,
+                'success',
+                'list of AMS Privilege found',
+                serializer.data
+            )
+            
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+
+    @transaction.atomic
+    def create(self, request, *args, **kwargs):
+        try:
+            form = request.data['form']
+            id_number = form[0]['id_number']
+            AMSPrivilege.objects.filter(id_number=id_number).delete()
+            serializer = AMSPrivilegeSerializer(
+                data=form, many=True
+            )
+            if serializer.is_valid(raise_exception=True):
+                serializer.save()
+                message = {
+                    'code': 201,
+                    'status': 'success',
+                    'message': 'AMS User Privilege successfully saved!',
+                    'results': serializer.data
+                }
+
+                return Response(message, status=status.HTTP_201_CREATED)
+
+        except ValidationError as e:
+            message = {
+                'code': 400,
+                'status': 'failed',
+                'message': str(e),
+            }
+            return Response(message, status=status.HTTP_400_BAD_REQUEST)
+
+        except IntegrityError as e:
+            error = 'Adding the same Department under the same Company is not allowed'
+            message = {
+                'code': 400,
+                'status': 'failed',
+                'message': error,
+            }
+            return Response(message,
+                            status=status.HTTP_400_BAD_REQUEST)
+
+        except Exception as e:
+            
+            message = {
+                'code': 500,
+                'status': 'failed',
+                'message': str(e),
+            }
+            return Response(message,
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)

app/applicationlayer/ams/ams_user_type/views.py

+from rest_framework.views import APIView
+from rest_framework.response import Response
+from app.entities import enums
+
+
+class AMSUserTypeViewSet(APIView):
+
+    def get(self, request, format=None):
+        manager_value = enums.AMSUserTypeEnum.MANAGER.value
+        user_client_value = enums.AMSUserTypeEnum.USER_CLIENT.value
+        support_value = enums.AMSUserTypeEnum.SUPPORT.value
+        viewer_value = enums.AMSUserTypeEnum.VIEWER.value
+        
+        manager_key = str(enums.AMSUserTypeEnum.MANAGER.name).capitalize()
+        user_client_key = str(enums.AMSUserTypeEnum.USER_CLIENT.name).replace('_', '/').title()
+        support_key = str(enums.AMSUserTypeEnum.SUPPORT.name).capitalize()
+        viewer_key = str(enums.AMSUserTypeEnum.VIEWER.name).capitalize()
+
+        data = {
+            "code": "200",
+            "status": "success",
+            "message": "list of ams user types",
+            "results":
+                [
+                    {
+                        "name": manager_key,
+                        "value": manager_value,
+                    },
+                    {
+                        "name": user_client_key,
+                        "value": user_client_value
+                    },
+                    {
+                        "name": support_key,
+                        "value": support_value
+                    },
+                    {
+                        "name": viewer_key,
+                        "value": viewer_value
+                    }
+                ]
+        }
+
+        return Response(data)
\ No newline at end of file

app/applicationlayer/ams/asset/serializers.py

+from app.entities.models import AMSAsset
+from rest_framework import serializers
+
+
+class AMSAssetSerializer(serializers.ModelSerializer):
+    
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        ret['asset_type'] = instance.asset_type.name
+        ret['in_qty'] = instance.ams_asset_to_assetdetail.filter(status='In-Store').count()
+        ret['out_qty'] = instance.ams_asset_to_assetdetail.filter(status='Deployed').count()
+        ret['unavailable'] = instance.ams_asset_to_assetdetail.filter(
+                                status__in=['Faulty', 'Returned', 'Written Off']
+                                ).count()
+        ret['created_by'] = instance.created_by.name
+        return ret
+
+    class Meta:
+        model = AMSAsset
+        fields = '__all__'

app/applicationlayer/ams/asset/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import AMSAsset
+
+
+class AMSAssetFilter(filters.FilterSet):
+
+    class Meta:
+        model = AMSAsset
+        fields = '__all__'

app/applicationlayer/ams/asset/views.py

+from app.entities.models import AMSAsset, AMSAssetType
+from rest_framework import viewsets, status
+from rest_framework.response import Response
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.applicationlayer.ams.asset.table_filters import AMSAssetFilter
+from app.applicationlayer.ams.asset_stock.serializers import AMSAssetStockSerializer
+from app.applicationlayer.ams.asset import serializers
+from django.db import transaction
+from app.applicationlayer.utils import(
+    CustomPagination, status_message_response
+)
+from rest_framework.decorators import action
+from app.applicationlayer.utils import log_save, enums
+from app.applicationlayer.utils import model_to_dict
+from django.db import IntegrityError
+from django.db.models import Q
+from app.helper.decorators import AssetValidation
+
+
+class AMSAssetViewSet(viewsets.ModelViewSet):
+    queryset = AMSAsset.objects.all()
+    serializer_class = serializers.AMSAssetSerializer
+    pagination_class = CustomPagination
+    lookup_field = 'code'
+    filter_backends = (
+        DjangoFilterBackend, SearchFilter,
+        OrderingFilter
+    )
+    ordering_fields = '__all__'
+    search_filter = (
+        'code',
+        'name',
+        'asset_type__name'
+    )
+
+    def list(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.get_queryset()).filter(is_active=True)
+
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Asset found!',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+
+
+    @AssetValidation
+    @transaction.atomic
+    def create(self, request, *args, **kwargs):
+        form = request.data
+        form['created_by'] = request.user.code
+        
+        serializer = self.get_serializer(data=form)
+        serializer.is_valid(raise_exception=True)
+        self.perform_create(serializer)
+
+        message = status_message_response(
+            201, 'success',
+            'New Asset created', serializer.data
+        )
+
+        return Response(
+            message
+        )
+
+    @AssetValidation
+    @transaction.atomic
+    def update(self, request, *args, **kwargs):
+        try:
+            
+            partial = kwargs.pop('partial', False)
+            instance = self.get_object()
+            form = request.data
+            form['created_by'] = request.user.code
+            serializer = self.get_serializer(instance, data=form, partial=partial)
+            serializer.is_valid(raise_exception=True)
+
+            old_instance = model_to_dict(instance)
+            self.perform_update(serializer)
+            new_instance = serializer.data
+
+            log_save(
+                enums.LogEnum.UPDATE.value,
+                enums.LogEntitiesEnum.AMSAsset.value,
+                old_instance['id'],
+                old_instance,
+                new_instance
+            )
+
+            return Response(serializer.data)
+        except IntegrityError as e:
+            return Response(
+                {"message": "Cannot delete or update this reocrd it has foreign key constraint to other tables"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+    def retrieve(self, request, *args, **kwargs):
+        instance = self.get_object()
+        serializer = self.get_serializer(instance)
+        return Response(serializer.data)
+
+    @transaction.atomic
+    def destroy(self, request, *args, **kwargs):
+
+        instance = self.get_object()
+        if instance.ams_asset_to_assetdetail.count() > 0:
+            message = status_message_response(
+                400, 'Failed',
+                'This Asset had an Asset Stocks', model_to_dict(instance)
+            )
+            return Response(
+                message,
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        instance.is_active = False
+        instance.save()
+        new_instance = model_to_dict(instance)
+
+        log_save(
+            enums.LogEnum.DELETED.value,
+            enums.LogEntitiesEnum.AMSAsset.value,
+            new_instance['id'],
+            new_instance,
+            ''
+        )
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @action(
+        methods=['PATCH'], detail=True,
+        url_path='restore', url_name='restore'
+    )
+    def restore(self, request, code=None):
+
+        try:
+            instance = self.get_object()
+            instance.is_active = True
+            instance.save()
+            new_instance = model_to_dict(instance)
+
+            log_save(
+                enums.LogEnum.UPDATE.value,
+                enums.LogEntitiesEnum.AMSAsset.value,
+                new_instance['id'],
+                new_instance,
+                ''
+            )
+
+            message = status_message_response(
+                200, 'success',
+                'Archived Asset restored',
+                ''
+            )
+
+            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)
+
+    @action(methods=['GET'], detail=True,
+            url_path='stock-list', url_name='stock_list')
+    def stock_list(self, request, code):
+        self.serializer_class = AMSAssetStockSerializer
+        queryset = self.get_object().ams_asset_to_assetdetail.all()
+        page = self.paginate_queryset(queryset)
+        
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Archived Assets found',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+
+    @action(
+        methods=['GET'], detail=False,
+        url_path='archived', url_name='archived'
+    )
+    def archived(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.get_queryset())
+        queryset = queryset.filter(is_active=False)
+
+        page = self.paginate_queryset(queryset)
+        
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Archived Assets found',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
\ No newline at end of file

app/applicationlayer/ams/asset_group/serializers.py

+from app.entities import models
+from rest_framework import serializers
+from app.applicationlayer.utils import model_to_dict
+from django.db.models import Q
+
+
+class AssetGroupSerializerList(serializers.ModelSerializer):
+
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+
+        ret['asset_type_count'] = instance.ams_asset_to_assetgroup.values('asset__asset_type').distinct().count()
+        ret['asset_count'] = instance.ams_asset_to_assetgroup.values('asset').distinct().count()
+        ret['asset_stock_count'] = instance.ams_asset_to_assetgroup.count()
+        
+        return ret
+
+    class Meta:
+        model = models.AMSAssetGroup
+        fields = '__all__'
+        read_only_fields = ['created', 'code']
+
+
+class AssetGroupSerializer(serializers.ModelSerializer):
+
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+
+        ret['asset_type_count'] = instance.ams_asset_to_assetgroup.values('asset__asset_type').distinct().count()
+        ret['asset_count'] = instance.ams_asset_to_assetgroup.values('asset').distinct().count()
+        ret['asset_stock_count'] = instance.ams_asset_to_assetgroup.count()
+        
+        ret['own'] = instance.ams_asset_to_assetgroup.filter(acquisition_type='Owned').count()
+        ret['loan'] = instance.ams_asset_to_assetgroup.filter(acquisition_type='Loan').count()
+        ret['in_qty'] = instance.ams_asset_to_assetgroup.filter(status='In-Store').count()
+        ret['out_qty'] = instance.ams_asset_to_assetgroup.filter(status='Deployed').count()
+        ret['unavailable'] = instance.ams_asset_to_assetgroup.filter(
+                                status__in=['Faulty', 'Returned', 'Written Off']
+                                ).count()
+        ret['in_store'] = instance.ams_asset_to_assetgroup.filter(status='In-Store').count()
+        ret['deployed'] = instance.ams_asset_to_assetgroup.filter(status='Deployed').count()
+        ret['returned'] = instance.ams_asset_to_assetgroup.filter(status='Returned').count()
+        ret['written_off'] = instance.ams_asset_to_assetgroup.filter(status='Written Off').count()
+        ret['faulty'] = instance.ams_asset_to_assetgroup.filter(status='Faulty').count()
+
+        return ret
+
+    class Meta:
+        model = models.AMSAssetGroup
+        fields = '__all__'
+        read_only_fields = ['created', 'code']
\ No newline at end of file

app/applicationlayer/ams/asset_group/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import AMSAssetGroup
+
+
+class AssetGroupFilter(filters.FilterSet):
+
+    class Meta:
+        model = AMSAssetGroup
+        fields = '__all__'

app/applicationlayer/ams/asset_group/views.py

+from app.entities import models
+from rest_framework import viewsets, status
+from rest_framework.response import Response
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.applicationlayer.ams.asset_group.table_filters import AssetGroupFilter
+from app.applicationlayer.ams.asset_group import serializers
+from app.applicationlayer.utils import (
+    CustomPagination, status_message_response
+)
+from app.helper import decorators
+from django.db import transaction
+from rest_framework.decorators import action
+from app.applicationlayer.utils import log_save, enums
+from app.applicationlayer.utils import model_to_dict
+from app.helper.decorators import AssetGroupValidation
+from django.db import IntegrityError
+
+
+class AssetGroupViewset(viewsets.ModelViewSet):
+    queryset = models.AMSAssetGroup.objects.all()
+    serializer_class = serializers.AssetGroupSerializer
+    pagination_class = CustomPagination
+    lookup_field = "code"
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    ordering_fields = '__all__'
+    search_fields = (
+        'code', 'name'
+    )
+
+    @AssetGroupValidation
+    @transaction.atomic
+    def create(self, request, *args, **kwargs):
+        form = request.data
+        form['created_by'] = request.user.code
+
+        serializer = self.get_serializer(data=form)
+        serializer.is_valid(raise_exception=True)
+        self.perform_create(serializer)
+
+        message = status_message_response(
+            201, 'success',
+            'New Asset Group created', serializer.data
+        )
+
+        return Response(
+            message
+        )
+
+    # @AssetGroupValidation
+    @transaction.atomic
+    def update(self, request, *args, **kwargs):
+        try:
+            partial = kwargs.pop('partial', False)
+            instance = self.get_object()
+            form = request.data
+            form['created_by'] = request.user.code
+            serializer = self.get_serializer(instance, data=form, partial=partial)
+            serializer.is_valid(raise_exception=True)
+
+            old_instance = model_to_dict(instance)
+            self.perform_update(serializer)
+            new_instance = serializer.data
+
+            log_save(
+                enums.LogEnum.UPDATE.value,
+                enums.LogEntitiesEnum.AMSAssetGroup.value,
+                old_instance['id'],
+                old_instance,
+                new_instance
+            )
+
+            return Response(serializer.data)
+        except IntegrityError as e:
+            return Response(
+                {"message": "Cannot delete or update this record it has foreign key constraint to other tables"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+    def list(self, request, *args, **kwargs):
+
+        self.serializer_class = serializers.AssetGroupSerializerList
+        queryset = self.filter_queryset(self.get_queryset())
+
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Asset Groups found!',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+    
+    def retrieve(self, request, *args, **kwargs):
+        instance = self.get_object()
+        serializer = self.get_serializer(instance)
+        return Response(serializer.data)
+
+    @transaction.atomic
+    def destroy(self, request, *args, **kwargs):
+
+        instance = self.get_object()
+        if instance.ams_asset_to_assetgroup.count() > 0:
+            message = status_message_response(
+                400, 'Failed',
+                'This Asset Group had an Asset Stocks', model_to_dict(instance)
+            )
+            return Response(
+                message,
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        instance.is_active = False
+        instance.save()
+        new_instance = model_to_dict(instance)
+
+        log_save(
+            enums.LogEnum.DELETED.value,
+            enums.LogEntitiesEnum.AMSAssetGroup.value,
+            new_instance['id'],
+            new_instance,
+            ''
+        )
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @action(
+        methods=['GET'], detail=False,
+        url_path='archived', url_name='archived'
+    )
+    def archived(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.get_queryset())
+        queryset = queryset.filter(is_active=False)
+            
+        page = self.paginate_queryset(queryset)
+        
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Archived Asset Groups found',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+    
+    @action(
+        methods=['PATCH'], detail=True,
+        url_path='restore', url_name='restore'
+    )
+    def restore(self, request, code=None):
+
+        try:
+            instance = self.get_object()
+            instance.is_active = True
+            instance.save()
+            new_instance = model_to_dict(instance)
+
+            log_save(
+                enums.LogEnum.UPDATE.value,
+                enums.LogEntitiesEnum.AMSAssetGroup.value,
+                new_instance['id'],
+                new_instance,
+                ''
+            )
+
+            message = status_message_response(
+                200, 'success',
+                'Archived Asset Group restored',
+                ''
+            )
+
+            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)

app/applicationlayer/ams/asset_stock/serializers.py

+from app.entities.models import AMSAssetStock
+from rest_framework import serializers
+
+
+class AMSAssetStockSerializer(serializers.ModelSerializer):
+    
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        ret['asset_group'] = instance.asset_group.name
+        ret['asset'] = instance.asset.name
+        ret['asset_type'] = instance.asset.asset_type.name
+        ret['manager'] = instance.manager.name
+        ret['user_client'] = instance.user_client.name
+        # ret['created_by'] = {
+        #     "name": instance.created_by.name,
+        #     "code": instance.created_by.code
+        # }
+        return ret
+
+
+    class Meta:
+        model = AMSAssetStock
+        fields = '__all__'
\ No newline at end of file

app/applicationlayer/ams/asset_stock/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import AMSAssetStock
+
+
+class AMSAssetStockFilter(filters.FilterSet):
+
+    class Meta:
+        model = AMSAssetStock
+        fields = '__all__'
\ No newline at end of file

app/applicationlayer/ams/asset_stock/views.py

+from app.entities.models import AMSAssetStock
+from rest_framework import viewsets, status
+from rest_framework.response import Response
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.applicationlayer.ams.asset_stock.table_filters import AMSAssetStockFilter
+from app.applicationlayer.ams.asset_stock import serializers
+from django.db import transaction
+from app.applicationlayer.utils import(
+    CustomPagination, status_message_response
+)
+from rest_framework.decorators import action
+from app.applicationlayer.utils import log_save, enums
+from app.applicationlayer.utils import model_to_dict
+from django.db import IntegrityError
+from django.db.models import Q
+from app.helper.decorators import AssetStockValidation
+from django.db.models import Count
+
+
+class AMSAssetStockViewSet(viewsets.ModelViewSet):
+    queryset = AMSAssetStock.objects.all()
+    serializer_class = serializers.AMSAssetStockSerializer
+    pagination_class = CustomPagination
+    lookup_field = 'code'
+    filter_backends = (
+        DjangoFilterBackend, SearchFilter,
+        OrderingFilter
+    )
+    ordering_fields = '__all__'
+    search_filter = (
+        'code',
+        'name',
+        'asset_group__name',
+        'asset__name',
+        'asset_type__name',
+    )
+
+    def list(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.get_queryset()).filter(is_active=True)
+
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Asset Stock list found!',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+    
+    @action(detail=False,
+            methods=['get'],
+            url_path='dashboard',
+            name="Dashboard Summary")
+    def dashboard_asset(self, request):
+        
+        in_store = self.queryset.filter(
+            status__iexact='In-Store'
+        ).count()
+
+        deployed = self.queryset.filter(
+            status__iexact='Deployed'
+        ).count()
+
+        returned = self.queryset.filter(
+            status__iexact='Returned'
+        ).count()
+
+        written_off = self.queryset.filter(
+            status__iexact='Written Off'
+        ).count()
+        
+        faulty = self.queryset.filter(
+            status__iexact='Faulty'
+        ).count()
+        
+        in_qty = self.queryset.filter(
+            status__iexact='In-Store'
+        ).count()
+
+        out_qty = self.queryset.filter(
+            status__iexact='Deployed'
+        ).count()
+
+        unavailable = self.queryset.filter(
+            status__iexact=['Faulty', 'Returned', 'Written Off']
+        ).count()
+
+        top_asset_groups = self.queryset.values('asset_group__name', 'asset_group', 'asset').annotate(
+            asset_type_count=Count('asset__asset_type'),
+            asset_count=Count('asset'),
+            asset_stock_count=Count('asset_group')).order_by('-asset_group')
+
+        recent_reports = 0
+
+        message = {
+            'in_store': in_store,
+            'deployed': deployed,
+            'returned': returned,
+            'written_off': written_off,
+            'faulty': faulty,
+            'in_qty': in_qty,
+            'out_qty': out_qty,
+            'unavailable': unavailable,
+            'top_asset_groups': top_asset_groups,
+            'recent_reports': recent_reports,
+            'code': 200,
+            'status': 'success',
+            'message': 'Dashboard Summary'
+        }
+
+        return Response(message, status=status.HTTP_200_OK)
+
+    @AssetStockValidation
+    @transaction.atomic
+    def update(self, request, *args, **kwargs):
+        try:
+            partial = kwargs.pop('partial', False)
+            instance = self.get_object()
+            form = request.data
+            form['created_by'] = request.user.code
+            serializer = self.get_serializer(instance, data=form, partial=partial)
+            serializer.is_valid(raise_exception=True)
+
+            old_instance = model_to_dict(instance)
+            self.perform_update(serializer)
+            new_instance = serializer.data
+
+            log_save(
+                enums.LogEnum.UPDATE.value,
+                enums.LogEntitiesEnum.AMSReport.value,
+                old_instance['id'],
+                old_instance,
+                new_instance
+            )
+
+            return Response(serializer.data)
+        except IntegrityError as e:
+            return Response(
+                {"message": "Cannot delete or update this reocrd it has foreign key constraint to other tables"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+
+    @AssetStockValidation
+    @transaction.atomic
+    def create(self, request, *args, **kwargs):
+
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        self.perform_create(serializer)
+
+        message = status_message_response(
+            201, 'success',
+            'New Asset Stock created', serializer.data
+        )
+
+        return Response(
+            message
+        )
+
+
+    def retrieve(self, request, *args, **kwargs):
+        instance = self.get_object()
+        serializer = self.get_serializer(instance)
+        return Response(serializer.data)
+
+    @transaction.atomic
+    def destroy(self, request, *args, **kwargs):
+
+        instance = self.get_object()
+        instance.is_active = False
+        instance.save()
+        new_instance = model_to_dict(instance)
+
+        log_save(
+            enums.LogEnum.UPDATE.value,
+            enums.LogEntitiesEnum.AMSAssetStock.value,
+            new_instance['id'],
+            new_instance,
+            ''
+        )
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @action(
+        methods=['GET'], detail=False,
+        url_path='archived', url_name='archived'
+    )
+    def archived(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.get_queryset())
+        queryset = queryset.filter(is_active=False)
+            
+        page = self.paginate_queryset(queryset)
+        
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Archived Asset Stocks found',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+
+    @action(
+        methods=['PATCH'], detail=True,
+        url_path='restore', url_name='restore'
+    )
+    def restore(self, request, code=None):
+
+        try:
+            instance = self.get_object()
+            instance.is_active = True
+            instance.save()
+            new_instance = model_to_dict(instance)
+
+            log_save(
+                enums.LogEnum.UPDATE.value,
+                enums.LogEntitiesEnum.AMSAssetStock.value,
+                new_instance['id'],
+                new_instance,
+                ''
+            )
+
+            message = status_message_response(
+                200, 'success',
+                'Archived Asset Stock restored',
+                ''
+            )
+
+            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)

app/applicationlayer/ams/asset_type/serializers.py

+from app.entities import models
+from rest_framework import serializers
+from app.applicationlayer.utils import model_to_dict
+
+
+class AssetTypeSerializer(serializers.ModelSerializer):
+
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+
+        assets = instance.ams_asset_type.select_related()
+        # assets1 = instance.ams_asset_type.count()
+        # asset_stock1 = instance.ams_asset_type.values('')
+        # ams_asset_to_assetdetail
+        # print(assets1)
+        ams_stock_counter = 0
+
+        for asset in assets:
+            ams_stock_counter = ams_stock_counter + models.AMSAsset.objects.get(code=asset.code).ams_asset_to_assetdetail.count()
+        
+        ret['asset_count'] = assets.count()
+        ret['asset_stock_count'] = ams_stock_counter
+        
+        return ret
+
+    class Meta:
+        model = models.AMSAssetType
+        fields = '__all__'
+        read_only_fields = ['created', 'code']
\ No newline at end of file

app/applicationlayer/ams/asset_type/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import AMSAssetType
+
+
+class AssetTypeFilter(filters.FilterSet):
+
+    class Meta:
+        model = AMSAssetType
+        fields = '__all__'
\ No newline at end of file

app/applicationlayer/ams/asset_type/views.py

+from app.entities import models
+from rest_framework import viewsets, status
+from rest_framework.response import Response
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.applicationlayer.ams.asset_type.table_filters import AssetTypeFilter
+from app.applicationlayer.ams.asset_type import serializers
+from app.applicationlayer.utils import (
+    CustomPagination, status_message_response
+)
+from app.helper import decorators
+from django.db import transaction
+from rest_framework.decorators import action
+from app.applicationlayer.utils import model_to_dict
+from app.applicationlayer.utils import log_save, enums
+from app.applicationlayer.utils import model_to_dict
+from app.helper.decorators import AssetTypeValidation
+from django.db import IntegrityError
+
+
+class AssetTypeViewset(viewsets.ModelViewSet):
+
+    queryset = models.AMSAssetType.objects.all()
+    serializer_class = serializers.AssetTypeSerializer
+    pagination_class = CustomPagination
+    lookup_field = "code"
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    ordering_fields = '__all__'
+    search_fields = (
+        'code', 'name'
+    )
+
+    @AssetTypeValidation
+    @transaction.atomic
+    def create(self, request, *args, **kwargs):
+        form = request.data
+        form['created_by'] = request.user.code
+        
+        serializer = self.get_serializer(data=form)
+        serializer.is_valid(raise_exception=True)
+        self.perform_create(serializer)
+
+        message = status_message_response(
+            201, 'success',
+            'New Asset Type created', serializer.data
+        )
+
+        return Response(
+            message
+        )
+    
+    # @AssetTypeValidation
+    @transaction.atomic
+    def update(self, request, *args, **kwargs):
+        try:
+            
+            partial = kwargs.pop('partial', False)
+            instance = self.get_object()
+            form = request.data
+            form['created_by'] = request.user.code
+            serializer = self.get_serializer(instance, data=form, partial=partial)
+            serializer.is_valid(raise_exception=True)
+
+            old_instance = model_to_dict(instance)
+            self.perform_update(serializer)
+            new_instance = serializer.data
+
+            log_save(
+                enums.LogEnum.UPDATE.value,
+                enums.LogEntitiesEnum.AMSAsset.value,
+                old_instance['id'],
+                old_instance,
+                new_instance
+            )
+
+            return Response(serializer.data)
+
+        except IntegrityError as e:
+            return Response(
+                {"message": "Cannot delete or update this record it has foreign key constraint to other tables"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+    def list(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.get_queryset())
+
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Asset Types found!',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+    
+    def retrieve(self, request, *args, **kwargs):
+        instance = self.get_object()
+        serializer = self.get_serializer(instance)
+        return Response(serializer.data)
+
+    @transaction.atomic
+    def destroy(self, request, *args, **kwargs):
+        
+        instance = self.get_object()
+        if instance.ams_asset_type.count() > 0:
+            message = status_message_response(
+                400, 'Failed',
+                'This Asset Type had an Assets', model_to_dict(instance)
+            )
+            return Response(
+                message,
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        instance.is_active = False
+        instance.save()
+        new_instance = model_to_dict(instance)
+
+        log_save(
+            enums.LogEnum.DELETED.value,
+            enums.LogEntitiesEnum.AMSAssetType.value,
+            new_instance['id'],
+            new_instance,
+            ''
+        )
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @action(
+        methods=['GET'], detail=False,
+        url_path='archived', url_name='archived'
+    )
+    def archived(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.get_queryset())
+        queryset = queryset.filter(is_active=False)
+            
+        page = self.paginate_queryset(queryset)
+        
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Archived Asset Types found',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+        
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+    
+    @action(
+        methods=['PATCH'], detail=True,
+        url_path='restore', url_name='restore'
+    )
+    def restore(self, request, code=None):
+
+        try:
+            instance = self.get_object()
+            instance.is_active = True
+            instance.save()
+            new_instance = model_to_dict(instance)
+
+            log_save(
+                enums.LogEnum.UPDATE.value,
+                enums.LogEntitiesEnum.AMSAssetType.value,
+                new_instance['id'],
+                new_instance,
+                ''
+            )
+
+            message = status_message_response(
+                200, 'success',
+                'Archived Asset Type restored',
+                ''
+            )
+
+            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)
\ No newline at end of file

app/applicationlayer/ams/audit_trail/serializers.py

+from app.entities import models
+from rest_framework import serializers
+from app.applicationlayer.utils import model_to_dict
+
+
+class AuditTrailSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = models.AMSAuditTrail
+        fields = '__all__'
+        read_only_fields = ['created', 'code']
\ No newline at end of file

app/applicationlayer/ams/audit_trail/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import AMSAuditTrail
+
+
+class AuditTrailFilter(filters.FilterSet):
+
+    class Meta:
+        model = AMSAuditTrail
+        fields = '__all__'
\ No newline at end of file

app/applicationlayer/ams/audit_trail/views.py

+from app.entities import models
+from rest_framework import viewsets, status
+from rest_framework.response import Response
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.applicationlayer.ams.audit_trail.table_filters import AuditTrailFilter
+from app.applicationlayer.ams.audit_trail import serializers
+from app.applicationlayer.utils import (
+    CustomPagination, status_message_response
+)
+from app.helper import decorators
+from django.db import transaction
+from rest_framework.decorators import action
+from app.applicationlayer.utils import model_to_dict
+from app.applicationlayer.utils import log_save, enums
+from app.applicationlayer.utils import model_to_dict
+from django.db import IntegrityError
+
+
+class AMSAuditTrailViewset(viewsets.ModelViewSet):
+
+    queryset = models.AMSAuditTrail.objects.all()
+    serializer_class = serializers.AuditTrailSerializer
+    pagination_class = CustomPagination
+    lookup_field = "code"
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    ordering_fields = '__all__'
+    search_fields = (
+        'code', 'name'
+    )
+
+    def create(self, request, *args, **kwargs):
+        form = request.data
+        form['created_by'] = request.user.code
+        
+        serializer = self.get_serializer(data=form)
+        serializer.is_valid(raise_exception=True)
+        self.perform_create(serializer)
+
+        message = status_message_response(
+            201, 'success',
+            'New Audit Trail created', serializer.data
+        )
+
+        return Response(
+            message
+        )
+    
+    def list(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.get_queryset())
+
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Asset Types found!',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+
+
+def audit_trail_create(name, desc, asset_stock, created_by):
+    try:
+        models.AMSAuditTrail.objects.create(
+                name=name,
+                desciption=desc,
+                asset_stock=asset_stock,
+                created_by=created_by
+            )
+        
+        return True
+
+    except Exception as e:
+        message = {
+            'code': 500,
+            'status': 'failed',
+            'message': 'Request was not able to process' + str(e.__class__)
+        }
+        return Response(message,
+                        status=status.HTTP_500_INTERNAL_SERVER_ERROR)
\ No newline at end of file

app/applicationlayer/ams/master/ams_company/serializer.py

+from rest_framework import serializers
+from app.entities.models import Company
+
+
+class AMSCompanySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Company
+        fields = '__all__'

app/applicationlayer/ams/master/ams_company/table_filter.py

+from django_filters import rest_framework as filters
+from app.entities.models import Company
+
+
+class AMSCompanyFilterSet(filters.FilterSet):
+    class Meta:
+        model = Company
+        fields = '__all__'

app/applicationlayer/ams/master/ams_company/views.py

+from django_filters import rest_framework as filters
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.entities.models import (
+    Company, AMSPrivilege
+)
+from rest_framework import viewsets
+from app.applicationlayer.utils import (CustomPagination,
+                                        status_message_response)
+from django_filters.rest_framework import DjangoFilterBackend
+from app.applicationlayer.ams.master.ams_company import serializer
+from app.applicationlayer.ams.master.ams_company.table_filter import (
+    AMSCompanyFilterSet
+)
+from rest_framework.response import Response
+from django.db.models import Q
+from rest_framework.decorators import action
+
+
+class AMSCompanyFormViewSet(viewsets.ModelViewSet):
+    queryset = Company.objects.all()
+    serializer_class = serializer.AMSCompanySerializer
+    pagination_class = CustomPagination
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = AMSCompanyFilterSet
+    ordering_fields = '__all__'
+    search_fields = ('name',)
+    http_method_names = ['get']
+
+    def list(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.get_queryset())
+        allowed = AMSPrivilege.objects.filter(
+            Q(id_number=self.request.user.code)
+        ).values('department__company')
+        queryset = queryset.filter(code__in=allowed)
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'list of Company found',
+                serializer.data
+            )
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(queryset, many=True)
+        return Response(serializer.data)

app/applicationlayer/ams/master/ams_department/serializer.py

+from rest_framework import serializers
+from app.entities.models import Department
+
+
+class AMSDepartmentSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Department
+        fields = '__all__'

app/applicationlayer/ams/master/ams_department/table_filter.py

+from django_filters import rest_framework as filters
+from app.entities.models import Department
+
+
+class AMSDepartmentFilterSet(filters.FilterSet):
+    class Meta:
+        model = Department
+        fields = '__all__'

app/applicationlayer/ams/master/ams_department/views.py

+from django_filters import rest_framework as filters
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.entities.models import (
+    Company, Department, AMSPrivilege
+)
+from rest_framework import viewsets
+from app.applicationlayer.utils import (CustomPagination,
+                                        status_message_response)
+from django_filters.rest_framework import DjangoFilterBackend
+from app.applicationlayer.ams.master.ams_department import serializer
+from app.applicationlayer.ams.master.ams_department.table_filter import (
+    AMSDepartmentFilterSet
+)
+from rest_framework.response import Response
+from django.db.models import Q
+from rest_framework.decorators import action
+
+
+class AMSDepartmentFormViewSet(viewsets.ModelViewSet):
+    queryset = Department.objects.all()
+    serializer_class = serializer.AMSDepartmentSerializer
+    pagination_class = CustomPagination
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = AMSDepartmentFilterSet
+    ordering_fields = '__all__'
+    search_fields = ('name',)
+    http_method_names = ['get']
+
+    def list(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.get_queryset())
+        allowed = AMSPrivilege.objects.filter(
+            Q(id_number=self.request.user.code)
+        ).values('department')
+        queryset = queryset.filter(code__in=allowed)
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'list of Department found',
+                serializer.data
+            )
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(queryset, many=True)
+        return Response(serializer.data)

app/applicationlayer/ams/report/serializers.py

+from app.entities import models
+from rest_framework import serializers
+from app.applicationlayer.utils import model_to_dict
+
+
+class AMSReportSerializer(serializers.ModelSerializer):
+
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        ret['created_by'] = instance.created_by.name
+        ret['report_type'] = instance.report_type.name
+        ret['unique_identifier'] = instance.asset_stock.unique_identifier
+        ret['asset'] = instance.asset_stock.asset.name
+        ret['asset_type'] = instance.asset_stock.asset.asset_type.name
+        del ret['asset_stock']
+        
+        return ret
+
+    class Meta:
+        model = models.AMSReport
+        fields = '__all__'
\ No newline at end of file

app/applicationlayer/ams/report/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import AMSReport
+
+
+class AMSReportFilter(filters.FilterSet):
+
+    class Meta:
+        model = AMSReport
+        fields = '__all__'
\ No newline at end of file

app/applicationlayer/ams/report/views.py

+from app.entities import models
+from rest_framework import viewsets, status
+from rest_framework.response import Response
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.applicationlayer.ams.report.table_filters import AMSReportFilter
+from app.applicationlayer.ams.report import serializers
+from app.applicationlayer.utils import (
+    CustomPagination, status_message_response
+)
+from app.helper import decorators
+from django.db import transaction
+from app.applicationlayer.utils import model_to_dict
+from app.applicationlayer.utils import log_save, enums
+from django.db import IntegrityError
+from rest_framework.decorators import action
+
+
+class AMSReportViewset(viewsets.ModelViewSet):
+
+    queryset = models.AMSReport.objects.all()
+    serializer_class = serializers.AMSReportSerializer
+    pagination_class = CustomPagination
+    lookup_field = "code"
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    ordering_fields = '__all__'
+    search_fields = (
+        'code', 'name'
+    )
+
+    @transaction.atomic
+    def create(self, request, *args, **kwargs):
+
+        form = request.data
+        form['created_by'] = request.user.code
+
+        serializer = self.get_serializer(data=form)
+        # serializer.is_valid(raise_exception=True)
+        if serializer.is_valid(raise_exception=True):
+            serializer.save(created_by=self.request.user)
+            self.perform_create(serializer)
+
+            message = status_message_response(
+                201, 'success',
+                'New Report created', serializer.data
+            )
+
+            return Response(
+                message
+            )
+
+
+    def update(self, request, *args, **kwargs):
+        try:
+            
+            partial = kwargs.pop('partial', False)
+            instance = self.get_object()
+            form = request.data
+            form['created_by'] = request.user.code
+            serializer = self.get_serializer(instance, data=form, partial=partial)
+            serializer.is_valid(raise_exception=True)
+
+            old_instance = model_to_dict(instance)
+            self.perform_update(serializer)
+            new_instance = serializer.data
+
+            log_save(
+                enums.LogEnum.UPDATE.value,
+                enums.LogEntitiesEnum.AMSReport.value,
+                old_instance['id'],
+                old_instance,
+                new_instance
+            )
+
+            return Response(serializer.data)
+        except IntegrityError as e:
+            print(e)
+            return Response(
+                {"message": "Cannot delete or update this reocrd it has foreign key constraint to other tables"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+
+    def list(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.get_queryset()).filter(is_active=True)
+ 
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Report found!',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+    
+    def retrieve(self, request, *args, **kwargs):
+        instance = self.get_object()
+        serializer = self.get_serializer(instance)
+        return Response(serializer.data)
+
+    @transaction.atomic
+    def destroy(self, request, *args, **kwargs):
+
+        instance = self.get_object()
+        instance.is_active = False
+        instance.save()
+        new_instance = model_to_dict(instance)
+
+        log_save(
+            enums.LogEnum.UPDATE.value,
+            enums.LogEntitiesEnum.AMSReport.value,
+            new_instance['id'],
+            new_instance,
+            ''
+        )
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+    @action(
+        methods=['GET'], detail=False,
+        url_path='archived', url_name='archived'
+    )
+    def archived(self, request, *args, **kwargs):
+        self.serializer_class = serializers.AMSReportSerializer
+        queryset = self.filter_queryset(self.queryset).filter(is_active=False)
+        
+        
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Archived Report found',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+
+
+    @action(
+        methods=['PATCH'], detail=True,
+        url_path='restore', url_name='restore'
+    )
+    def restore(self, request, code=None):
+
+        try:
+            instance = self.get_object()
+            instance.is_active = True
+            instance.save()
+            new_instance = model_to_dict(instance)
+
+            log_save(
+                enums.LogEnum.UPDATE.value,
+                enums.LogEntitiesEnum.AMSReport.value,
+                new_instance['id'],
+                new_instance,
+                ''
+            )
+
+            message = status_message_response(
+                200, 'success',
+                'Archived Report restored',
+                ''
+            )
+
+            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)

app/applicationlayer/ams/report_type/serializers.py

+from app.entities import models
+from rest_framework import serializers
+from app.applicationlayer.utils import model_to_dict
+
+
+class AMSReportTypeSerializer(serializers.ModelSerializer):
+
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        ret['created_by'] = instance.created_by.name
+        return ret
+
+    class Meta:
+        model = models.AMSReportType
+        fields = '__all__'
\ No newline at end of file

app/applicationlayer/ams/report_type/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import AMSReportType
+
+
+class AMSReportTypeFilter(filters.FilterSet):
+
+    class Meta:
+        model = AMSReportType
+        fields = '__all__'
\ No newline at end of file

app/applicationlayer/ams/report_type/views.py

+from app.entities import models
+from rest_framework import viewsets, status
+from rest_framework.response import Response
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.applicationlayer.ams.report_type.table_filters import AMSReportTypeFilter
+from app.applicationlayer.ams.report_type import serializers
+from app.applicationlayer.utils import (
+    CustomPagination, status_message_response
+)
+from app.helper import decorators
+from django.db import transaction
+from app.applicationlayer.utils import model_to_dict
+from app.applicationlayer.utils import log_save, enums
+from django.db import IntegrityError
+from rest_framework.decorators import action
+
+
+class AMSReportTypeViewset(viewsets.ModelViewSet):
+
+    queryset = models.AMSReportType.objects.all()
+    serializer_class = serializers.AMSReportTypeSerializer
+    pagination_class = CustomPagination
+    lookup_field = "code"
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    ordering_fields = '__all__'
+    search_fields = (
+        'code', 'name'
+    )
+
+    @transaction.atomic
+    def create(self, request, *args, **kwargs):
+
+        form = request.data
+        form['created_by'] = request.user.code
+
+        serializer = self.get_serializer(data=form)
+        # serializer.is_valid(raise_exception=True)
+        if serializer.is_valid(raise_exception=True):
+            serializer.save(created_by=self.request.user)
+            self.perform_create(serializer)
+
+            message = status_message_response(
+                201, 'success',
+                'New Report Type created', serializer.data
+            )
+
+            return Response(
+                message
+            )
+
+
+    def update(self, request, *args, **kwargs):
+        try:
+            
+            partial = kwargs.pop('partial', False)
+            instance = self.get_object()
+            form = request.data
+            form['created_by'] = request.user.code
+            serializer = self.get_serializer(instance, data=form, partial=partial)
+            serializer.is_valid(raise_exception=True)
+
+            old_instance = model_to_dict(instance)
+            self.perform_update(serializer)
+            new_instance = serializer.data
+
+            log_save(
+                enums.LogEnum.UPDATE.value,
+                enums.LogEntitiesEnum.AMSReportType.value,
+                old_instance['id'],
+                old_instance,
+                new_instance
+            )
+
+            return Response(serializer.data)
+        except IntegrityError as e:
+            print(e)
+            return Response(
+                {"message": "Cannot delete or update this reocrd it has foreign key constraint to other tables"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+    def list(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.queryset).filter(is_active=True)
+        
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Report Types found!',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+    
+    def retrieve(self, request, *args, **kwargs):
+        instance = self.get_object()
+        serializer = self.get_serializer(instance)
+        return Response(serializer.data)
+
+    @transaction.atomic
+    def destroy(self, request, *args, **kwargs):
+
+        instance = self.get_object()
+        instance.is_active = False
+        instance.save()
+        new_instance = model_to_dict(instance)
+
+        log_save(
+            enums.LogEnum.UPDATE.value,
+            enums.LogEntitiesEnum.AMSReportType.value,
+            new_instance['id'],
+            new_instance,
+            ''
+        )
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+    @action(
+        methods=['GET'], detail=False,
+        url_path='archived', url_name='archived'
+    )
+    def archived(self, request, *args, **kwargs):
+        self.serializer_class = serializers.AMSReportTypeSerializer
+        queryset = self.filter_queryset(self.queryset).filter(is_active=False)
+        
+        
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Archived Report type found',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+
+    @action(
+        methods=['PATCH'], detail=True,
+        url_path='restore', url_name='restore'
+    )
+    def restore(self, request, code=None):
+
+        try:
+            instance = self.get_object()
+            instance.is_active = True
+            instance.save()
+            new_instance = model_to_dict(instance)
+
+            log_save(
+                enums.LogEnum.UPDATE.value,
+                enums.LogEntitiesEnum.AMSReportType.value,
+                new_instance['id'],
+                new_instance,
+                ''
+            )
+
+            message = status_message_response(
+                200, 'success',
+                'Archived Report Type restored',
+                ''
+            )
+
+            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)

app/applicationlayer/ams/urls_ams.py

+from django.urls import path, include
+from rest_framework import routers
+from django.conf.urls import url
+from rest_framework.urlpatterns import format_suffix_patterns
+
+from app.applicationlayer.ams.asset_group import views as assetgroup
+from app.applicationlayer.ams.ams_privilege import views as amsprivilege
+from app.applicationlayer.ams.ams_user_type.views import AMSUserTypeViewSet
+from app.applicationlayer.ams.asset_type import views as assettype
+from app.applicationlayer.ams.asset.views import AMSAssetViewSet
+from app.applicationlayer.ams.asset_stock.views import AMSAssetStockViewSet
+from app.applicationlayer.ams.report_type.views import AMSReportTypeViewset
+from app.applicationlayer.ams.report.views import AMSReportViewset
+from app.applicationlayer.ams.audit_trail.views import AMSAuditTrailViewset
+
+# list of ams companies and department
+from app.applicationlayer.ams.master.ams_company.views import AMSCompanyFormViewSet
+from app.applicationlayer.ams.master.ams_department.views import AMSDepartmentFormViewSet
+
+router = routers.DefaultRouter()
+
+router.register(r'asset-group', assetgroup.AssetGroupViewset)
+router.register(r'asset-type', assettype.AssetTypeViewset)
+router.register(r'ams-privilege', amsprivilege.AMSPrivilegeViewSet)
+router.register(r'asset', AMSAssetViewSet)
+router.register(r'asset-stock', AMSAssetStockViewSet)
+router.register(r'report-type', AMSReportTypeViewset)
+router.register(r'report', AMSReportViewset)
+router.register(r'audit-trail', AMSAuditTrailViewset)
+
+router.register(r'ams-companies', AMSCompanyFormViewSet)
+router.register(r'ams-departments', AMSDepartmentFormViewSet)
+
+urlpatterns = [
+    path('', include(router.urls)),
+    url(r'^ams-user-types/$', AMSUserTypeViewSet.as_view(), name="ams-user-types"),
+]
\ No newline at end of file

app/applicationlayer/apps.py

+from django.apps import AppConfig
+
+
+class ApplicationLayerConfig(AppConfig):
+    name = 'application_layer'

app/applicationlayer/cms/allowed_company/serializer.py

+from rest_framework import serializers
+from app.entities.models import AllowedCompany
+from app.applicationlayer.utils import model_to_dict
+
+
+class AllowedCompanySerializer(serializers.ModelSerializer):
+
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        ret['department'] = model_to_dict(instance.group_pivots)
+        ret['company'] = model_to_dict(instance.company_pivot)
+        return ret
+    
+    class Meta:
+        model = AllowedCompany
+        fields = '__all__'
+

app/applicationlayer/cms/allowed_company/table_filter.py

+from django_filters import rest_framework as filters
+from app.entities.models import AllowedCompany
+from django.db.models import Q
+
+
+class AllowedCompanyFilterSet(filters.FilterSet):
+    # search = filters.CharFilter(method='search_bar', label='search')
+    # def search_bar(self, queryset, name, value):
+    #     return queryset.filter(
+    #         Q(username__icontains=value) |
+    #         Q(first_name__icontains=value) |
+    #         Q(last_name__icontains=value))
+    
+    class Meta:
+        model = AllowedCompany
+        fields = '__all__'

app/applicationlayer/cms/allowed_company/views.py

+from rest_framework import status, viewsets
+from rest_framework.response import Response
+from app.entities.models import AllowedCompany
+from app.applicationlayer.utils import (CustomPagination,
+                                        status_message_response)
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.applicationlayer.cms.allowed_company.serializer import (
+    AllowedCompanySerializer
+)
+from app.applicationlayer.cms.allowed_company.table_filter import (
+    AllowedCompanyFilterSet
+)
+from django.db import transaction
+from rest_framework.exceptions import ValidationError
+from django.db import IntegrityError
+
+
+class AllowedCompanyViewSet(viewsets.ModelViewSet):
+    queryset = AllowedCompany.objects.select_related(
+        'id_number', 'company_pivot', 'group_pivots'
+    ).all()
+    serializer_class = AllowedCompanySerializer
+    pagination_class = CustomPagination
+    lookup_field = 'code'
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = AllowedCompanyFilterSet
+    ordering_fields = '__all__'
+    search_fields = (
+        'id_number__code', 'company_pivot__code',
+        'group_pivots__code'
+    )
+    
+    def list(self, request, *args, **kwargs):
+        # hello again
+        queryset = self.filter_queryset(self.get_queryset())
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+            
+            message = status_message_response(
+                200,
+                'success',
+                'list of Users found',
+                serializer.data
+            )
+            
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+
+    @transaction.atomic
+    def create(self, request, *args, **kwargs):
+        try:
+            form = request.data['form']
+            id_number = form[0]['id_number']
+            AllowedCompany.objects.filter(id_number=id_number).delete()
+            serializer = AllowedCompanySerializer(
+                data=form, many=True
+            )
+            if serializer.is_valid(raise_exception=True):
+                serializer.save()
+                message = {
+                    'code': 201,
+                    'status': 'success',
+                    'message': 'Form Details successfully saved!',
+                    'results': serializer.data
+                }
+
+                return Response(message, status=status.HTTP_201_CREATED)
+        except ValidationError as e:
+            message = {
+                'code': 400,
+                'status': 'failed',
+                'message': str(e),
+            }
+            return Response(message, status=status.HTTP_400_BAD_REQUEST)
+
+        except IntegrityError as e:
+            error = 'Adding the same Department under the same Company is not allowed'
+            message = {
+                'code': 400,
+                'status': 'failed',
+                'message': error,
+            }
+            return Response(message,
+                            status=status.HTTP_400_BAD_REQUEST)
+
+        except Exception as e:
+            message = {
+                'code': 500,
+                'status': 'failed',
+                'message': str(e),
+            }
+            return Response(message,
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)

app/applicationlayer/cms/auto_email/cancel.py

+from app.entities import models
+from datetime import datetime
+from rest_framework.response import Response
+from rest_framework import status, views
+from django.db.models import Q
+from django.conf import settings
+from app.helper.email_service import sender
+from app.applicationlayer.utils import main_threading
+from rest_framework.permissions import AllowAny
+
+CR_FRONT_LINK = settings.CR_FRONT_LINK
+
+class CancelTriggerAPIView(views.APIView):
+
+    permission_classes = (AllowAny,)
+
+    def get(self, request):
+        date_now = datetime.now()
+        today_mail = models.CancelTrigger.objects.filter(
+            Q(auto_cancel_date=date_now.strftime('%Y-%m-%d 00:00:00.000'))
+        )
+        
+        list_of_emails = []
+        for data in today_mail:
+            
+            if data.is_sent is False and data.form_code.status == 'Pending' and data.frm_approver.is_action is True:
+                
+                cr_link = f'{CR_FRONT_LINK}/{data.form_code}'
+                
+                requestor_name = data.form_code.requested_by_user.name
+                auto_cancel_date = data.auto_cancel_date.strftime('%B %d, %Y')
+                date_submitted_last_approver = data.date_submitted_last_approver.strftime('%B %d, %Y')
+                approver_pending_action = data.frm_approver.user.name
+                cr_number = data.form_code.requested_to_template_id
+                cr_name = data.form_code.requested_to_template_name
+                company_requestedto = data.form_code.requested_to_company.name
+                department_requestedto = data.form_code.requested_to_department.name
+                priority_level = data.form_code.requested_to_priority
+                form_status = data.form_code.status
+                url = cr_link
+                requestor_recipient = data.form_code.requested_by_user.email
+                admin = 'Test'
+                
+                args_requestor = [requestor_name, auto_cancel_date,
+                    date_submitted_last_approver, approver_pending_action,
+                    cr_number, cr_name, company_requestedto,
+                    department_requestedto, priority_level, form_status, url,
+                    requestor_recipient, admin]
+                
+                main_threading(args_requestor, sender.routing_table_cancelled)
+
+                cancel = models.ChangeRequestFormHeader.objects.filter(
+                    form_code=data.form_code
+                ).update(status='Cancelled')
+                
+                list_of_emails.append(data.form_code.form_code)
+
+        today_mail.update(is_sent=True)
+
+        return Response(
+            {"list of emails": list_of_emails},
+            status=status.HTTP_200_OK
+        )
+

app/applicationlayer/cms/auto_email/overdue.py

+from app.entities import models
+from datetime import datetime
+from rest_framework.response import Response
+from rest_framework import status, views
+from django.db.models import Q
+from django.conf import settings
+from app.helper.email_service import sender
+from app.applicationlayer.utils import main_threading
+from rest_framework.permissions import AllowAny
+
+CR_FRONT_LINK = settings.CR_FRONT_LINK
+
+class OverdueTriggerAPIView(views.APIView):
+
+    permission_classes = (AllowAny,)
+
+    def get(self, request):
+        date_now = datetime.now()
+        today_mail = models.OverdueTrigger.objects.filter(
+            Q(overdue_date=date_now.strftime('%Y-%m-%d 00:00:00.000')) &
+            Q(is_sent=False)
+        )
+        
+        list_of_emails = []
+        for data in today_mail:
+            
+            if data.is_sent is False and (data.form_code.status == 'Pending' or
+               data.form_code.status == 'Approved' or
+               data.form_code.status == 'Rejected'):
+                
+                cr_link = f'{CR_FRONT_LINK}/{data.form_code}'
+                
+                requestor_name = data.form_code.requested_by_user.name
+                target_date = data.form_code.requested_to_target_date.strftime('%B %d, %Y')
+                cr_number = data.form_code.requested_to_template_id
+                cr_name = data.form_code.requested_to_template_name
+                company_requestedto = data.form_code.requested_to_company.name
+                department_requestedto = data.form_code.requested_to_department.name
+                priority_level = data.form_code.requested_to_priority
+                form_status = data.form_code.status
+                url = cr_link
+                requestor_recipient = data.form_code.requested_by_user.email
+                admin = 'Test'
+                
+                args_requestor = [requestor_name, target_date,
+                    cr_number, cr_name, company_requestedto,
+                    department_requestedto, priority_level, form_status, url,
+                    requestor_recipient, admin]
+                
+                main_threading(args_requestor, sender.routing_table_overdue)
+
+                list_of_emails.append(data.form_code.form_code)
+
+        today_mail.update(is_sent=True)
+
+        return Response(
+            {"list of emails": list_of_emails},
+            status=status.HTTP_200_OK
+        )
+
+

app/applicationlayer/cms/auto_email/reminder.py

+from app.entities import models
+from datetime import datetime
+from rest_framework.response import Response
+from rest_framework import status, views
+from django.db.models import Q
+from django.conf import settings
+from datetime import timedelta
+from app.helper.email_service import sender
+from app.applicationlayer.utils import main_threading
+from rest_framework.permissions import AllowAny
+
+CR_FRONT_LINK = settings.CR_FRONT_LINK
+
+class ReminderTriggerAPIView(views.APIView):
+
+    permission_classes = (AllowAny,)
+    
+    def get(self, request):
+        date_now = datetime.now()
+        next_day = date_now + timedelta(days=1)
+        today_mail = models.ReminderTrigger.objects.filter(
+            Q(date_from__gte=date_now.strftime('%Y-%m-%d 00:00:00.000')) &
+            Q(date_to__lte=date_now.strftime('%Y-%m-%d 00:00:00.000')) &
+            Q(date_to_send=date_now.strftime('%Y-%m-%d 00:00:00.000'))
+        )
+        
+        list_of_emails = []
+        for data in today_mail:
+            
+            if data.frm_approver.is_action is True and data.form_code.status == 'Pending':
+                
+                # common details
+                cr_link = f'{CR_FRONT_LINK}/{data.frm_approver.form_code}'
+
+                auto_cancel_date = data.auto_cancel_date.strftime('%B %d, %Y')
+                date_submitted_last_approver = data.date_submitted_last_approver.strftime('%B %d, %Y')
+                cr_number = data.frm_approver.form_code.requested_to_template_id
+                cr_name = data.frm_approver.form_code.requested_to_template_name
+                company_requestedto = data.frm_approver.form_code.requested_to_company.name
+                department_requestedto = data.frm_approver.form_code.requested_to_department.name
+                priority_level = data.frm_approver.form_code.requested_to_priority
+                form_status = data.frm_approver.form_code.status
+                url = cr_link
+                admin = 'Test'
+                
+                # approver details
+
+                name = data.frm_approver.user.name
+                recipient = data.frm_approver.user.email
+
+                args_approver = [name, auto_cancel_date, date_submitted_last_approver,
+                    cr_number, cr_name, company_requestedto, department_requestedto,
+                    priority_level, form_status, url, recipient, admin]
+
+                main_threading(args_approver, sender.routing_table_reminder_approver)
+                list_of_emails.append(data.frm_approver.code)
+                
+                # requestor details
+                
+                requestor_name = data.frm_approver.form_code.requested_by_user.name
+                requestor_recipient = data.frm_approver.form_code.requested_by_user.email
+
+                args_requestor = [requestor_name, auto_cancel_date, date_submitted_last_approver,
+                    name, cr_number, cr_name, company_requestedto,
+                    department_requestedto, priority_level, form_status, url,
+                    requestor_recipient, admin]
+                
+                main_threading(args_requestor, sender.routing_table_reminder_requestor)
+                
+                today_mail.update(date_to_send=next_day.strftime('%Y-%m-%d 00:00:00.000'))
+
+        return Response(
+            {"list of emails": list_of_emails},
+            status=status.HTTP_200_OK
+        )
+

app/applicationlayer/cms/cms_settings/serializer.py

+from rest_framework import serializers
+from app.entities.models import ChangeRequestSettings
+from app.applicationlayer.utils import model_to_dict
+
+
+class ChangeRequestSettingsSerializer(serializers.ModelSerializer):
+
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+
+        if instance.behalf_user:
+
+            behalf_user_object = {
+                "id": instance.behalf_user.id,
+                "name": instance.behalf_user.name,
+                "username": instance.behalf_user.username,
+                "code": instance.behalf_user.code,
+                "email": instance.behalf_user.email,
+                "contact_no": instance.behalf_user.contact_no
+            }
+
+            ret['behalf_user'] = behalf_user_object
+            
+        return ret
+
+    class Meta:
+        model = ChangeRequestSettings
+        fields = '__all__'
+        read_only_fields = ['created', 'code']
+

app/applicationlayer/cms/cms_settings/table_filter.py

+from django_filters import rest_framework as filters
+from app.entities.models import ChangeRequestSettings
+
+
+class ChangeRequestSettingsFilterSet(filters.FilterSet):
+    
+    class Meta:
+        model = ChangeRequestSettings
+        fields = '__all__'

app/applicationlayer/cms/cms_settings/views.py

+from rest_framework import status, viewsets
+from rest_framework.response import Response
+from app.entities import enums
+from app.entities.models import ChangeRequestSettings, User
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.applicationlayer.cms.cms_settings.serializer import (
+    ChangeRequestSettingsSerializer
+)
+from app.applicationlayer.cms.cms_settings.table_filter import (
+    ChangeRequestSettingsFilterSet
+)
+from django.db import transaction
+from rest_framework.exceptions import ValidationError
+from django.db import IntegrityError
+from app.applicationlayer.utils import (
+    main_threading, log_save, model_to_dict,
+    CustomPagination,status_message_response
+)
+from app.helper.email_service import sender
+from app.applicationlayer.utils import error_message
+
+
+class CMSSettingsViewSet(viewsets.ModelViewSet):
+    queryset = ChangeRequestSettings.objects.all()
+    serializer_class = ChangeRequestSettingsSerializer
+    pagination_class = CustomPagination
+    lookup_field = 'code'
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = ChangeRequestSettingsFilterSet
+    ordering_fields = '__all__'
+    search_fields = (
+        'active_user__code',
+        'behalf_user__code'
+    )
+
+    def list(self, request, *args, **kwargs):
+
+        logged_user = self.request.user.code
+        queryset = self.filter_queryset(
+            self.get_queryset().filter(active_user=logged_user)
+        )
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of CMS Settings found',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+
+    @transaction.atomic
+    def destroy(self, request, *args, **kwargs):
+
+        instance = self.get_object()
+        logged_user = self.request.user.name
+        new_instance = model_to_dict(instance)
+        # behalf = ChangeRequestSettings.objects.filter(code=str(instance)).first()
+        
+        behalf_name = instance.behalf_user.name
+        behalf_email = instance.behalf_user.email
+        
+        self.perform_destroy(instance)
+
+        log_save(
+            enums.LogEnum.DELETED.value,
+            enums.LogEntitiesEnum.ChangeRequestSettings.value,
+            new_instance['id'],
+            new_instance,
+            ''
+        )
+
+        active_user = self.request.user.name
+        admin = request.user.email
+        linking_verb = 'as'
+
+        args = [behalf_name, 'Removed', active_user, behalf_email, admin, linking_verb]
+        main_threading(args, sender.on_behalf)
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @transaction.atomic
+    def create(self, request, *args, **kwargs):
+        try:
+            logged_user = self.request.user.code
+            
+            data_cms_settings = []
+            behalf_user_list = []
+            
+            cms_settings = request.data['cms_settings']
+            for cms_setting in cms_settings:
+                
+                if cms_setting['behalf_user'] in behalf_user_list:
+                    return error_message('400', 'Please make sure to add unique on behalf users',
+                        'failed', status.HTTP_400_BAD_REQUEST)
+                else:
+                    behalf_user_list.append(cms_setting['behalf_user'])
+                    cms_setting['active_user'] = logged_user
+                    data_cms_settings.append(cms_setting)
+            
+            serializer = ChangeRequestSettingsSerializer(
+                data=data_cms_settings, many=True
+            )
+
+            ChangeRequestSettings.objects.filter(
+                active_user=logged_user
+            ).delete()
+
+            active_user = self.request.user.name
+            action = 'Added'
+            admin = request.user.email
+            linking_verb = 'on'
+
+            for data in data_cms_settings:
+                recipient = User.objects.get(
+                    code=str(data['behalf_user'])
+                )
+
+                args = [recipient.name, action, active_user, recipient.email, admin, linking_verb]
+                main_threading(args, sender.on_behalf)
+            
+            if serializer.is_valid(raise_exception=True):
+                serializer.save()
+
+                message = {
+                    'code': 201,
+                    'status': 'success',
+                    'message': 'CMS Settings successfully saved!',
+                    'results': serializer.data
+                }
+
+                return Response(message, status=status.HTTP_201_CREATED)
+
+        except ValidationError as e:
+            message = {
+                'code': 400,
+                'status': 'failed',
+                'message': str(e),
+            }
+            return Response(message, status=status.HTTP_400_BAD_REQUEST)
+
+        except Exception as e:
+            message = {
+                'code': 500,
+                'status': 'failed',
+                'message': str(e),
+            }
+            return Response(message,
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)

app/applicationlayer/cms/form/approver/serializers.py

+from app.entities import models
+from rest_framework import serializers
+
+
+class ChangeRequestFormApproversSerializer(
+    serializers.ModelSerializer
+):
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        
+        try:
+            ret['company'] = {
+                "id": instance.user.department.company.id,
+                "code": instance.user.department.company.code,
+                "name": instance.user.department.company.name
+            }
+            ret['department'] = {
+                "id": instance.user.department.id,
+                "code": instance.user.department.code,
+                "name": instance.user.department.name
+            }
+            user_object = {
+                "id": instance.user.id,
+                "name": instance.user.name,
+                "username": instance.user.username,
+                "code": instance.user.code,
+                "email": instance.user.email,
+                "contact_no": instance.user.contact_no
+            }
+            ret['user'] = user_object
+            ret['delegation'] = {
+                "id": instance.delegation.id,
+                "code": instance.delegation.code,
+                "name": instance.delegation.name
+            }
+            
+            if instance.form_code.status == 'Draft':
+                if instance.tmp_approver:
+                    
+                    if instance.tmp_approver.user:
+                        ret['editable_user'] = False
+                    else:
+                        ret['editable_user'] = True
+
+                    if instance.tmp_approver.company:
+                        ret['editable_comp'] = False
+                    else:
+                        ret['editable_comp'] = True
+
+                    if instance.tmp_approver.department:
+                        ret['editable_dept'] = False
+                    else:
+                        ret['editable_dept'] = True
+                    # not instance.tmp_approver.delegation.code  or 
+                    if instance.tmp_approver.delegation:
+                        ret['editable_deleg'] = False
+                    else:
+                        ret['editable_deleg'] = True
+
+                    if instance.tmp_approver.delegation:
+                        if instance.tmp_approver.delegation.name.lower() == 'requestor':
+                            ret['editable_user'] = False
+                            ret['editable_comp'] = False
+                            ret['editable_dept'] = False
+                            ret['editable_deleg'] = False
+
+                else:
+                    ret['editable_user'] = True
+                    ret['editable_comp'] = True
+                    ret['editable_dept'] = True
+                    ret['editable_deleg'] = True
+            else:
+                ret['editable_user'] = False
+                ret['editable_comp'] = False
+                ret['editable_dept'] = False
+                ret['editable_deleg'] = False
+
+            return ret
+        
+        except Exception as e:
+            
+            if instance.form_code.status == 'Draft':
+                if instance.tmp_approver:
+                    
+                    if instance.tmp_approver.user:
+                        ret['editable_user'] = False
+                    else:
+                        ret['user'] = None
+                        ret['editable_user'] = True
+
+                    if instance.tmp_approver.company:
+                        ret['company'] = {
+                           "id": instance.tmp_approver.company.id,
+                           "code": instance.tmp_approver.company.code,
+                           "name": instance.tmp_approver.company.name
+                        }
+                        
+                        ret['editable_comp'] = False
+                    else:
+                        ret['company'] = None
+                        ret['editable_comp'] = True
+
+                    if instance.tmp_approver.department:
+                        ret['department'] = {
+                            "id": instance.tmp_approver.department.id,
+                            "code": instance.tmp_approver.department.code,
+                            "name": instance.tmp_approver.department.name
+                        }
+                        ret['editable_dept'] = False
+                    else:
+                        ret['department'] = None
+                        ret['editable_dept'] = True
+
+                    if instance.tmp_approver.delegation:
+                        
+                        ret['delegation'] = {
+                            "id": instance.tmp_approver.delegation.id,
+                            "code": instance.tmp_approver.delegation.code,
+                            "name": instance.tmp_approver.delegation.name
+                        }
+                        ret['editable_deleg'] = False
+                    else:
+                        ret['delegation'] = None
+                        ret['editable_deleg'] = True
+
+                    if instance.tmp_approver.delegation:
+                        if instance.tmp_approver.delegation.name.lower() == 'requestor':
+                            ret['editable_user'] = False
+                            ret['editable_comp'] = False
+                            ret['editable_dept'] = False
+                            ret['editable_deleg'] = False
+
+                else:
+                    ret['editable_user'] = True
+                    ret['editable_comp'] = True
+                    ret['editable_dept'] = True
+                    ret['editable_deleg'] = True
+            else:
+                ret['editable_user'] = False
+                ret['editable_comp'] = False
+                ret['editable_dept'] = False
+                ret['editable_deleg'] = False
+
+            return ret
+
+    class Meta:
+        model = models.ChangeRequestFormApprovers
+        fields = '__all__'
+        read_only_fields = ['created', 'code']
+

app/applicationlayer/cms/form/approver/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import ChangeRequestFormApprovers
+
+
+class ApproverFilter(filters.FilterSet):
+
+    class Meta:
+        model = ChangeRequestFormApprovers
+        fields = '__all__'

app/applicationlayer/cms/form/approver/views.py

+from app.entities import models
+from rest_framework import viewsets, status
+from rest_framework.response import Response
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.applicationlayer.cms.form.approver.table_filters import ApproverFilter
+from app.applicationlayer.cms.form.approver import serializers
+from app.applicationlayer.utils import (
+    CustomPagination, status_message_response
+)
+
+
+class ChangeRequestFormApproversViewset(viewsets.ModelViewSet):
+    
+    queryset = models.ChangeRequestFormApprovers.objects.select_related(
+        'form_code', 'tmp_approver'
+    ).all().order_by('level')
+    serializer_class = serializers.ChangeRequestFormApproversSerializer
+    pagination_class = CustomPagination
+    lookup_field = 'code'
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = ApproverFilter
+    ordering_fields = '__all__'
+    search_fields = (
+        'name', 'code',
+        'department__company__name',
+        'department__name',
+        'email', 'contact_no'
+    )
+    
+    def list(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.get_queryset())
+
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Form Approvers found',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+    
+    def retrieve(self, request, *args, **kwargs):
+        instance = self.get_object()
+        serializer = self.get_serializer(instance)
+        return Response(serializer.data)
\ No newline at end of file

app/applicationlayer/cms/form/attachment/serializers.py

+from app.entities import models
+from rest_framework import serializers
+
+
+class ChangeRequestFormAttachmentsSerializer(
+    serializers.ModelSerializer
+):
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        user_object = {
+            "id": instance.uploaded_by.id,
+            "name": instance.uploaded_by.name,
+            "username": instance.uploaded_by.username,
+            "code": instance.uploaded_by.code,
+            "email": instance.uploaded_by.email,
+            "contact_no": instance.uploaded_by.contact_no
+        }
+        ret['uploaded_by'] = user_object
+        
+        ret['file_upload'] = self.context['request'].build_absolute_uri(
+            instance.file_upload.url.url)
+        ret['file_upload_id'] = instance.file_upload.id
+        return ret
+    
+    class Meta:
+        model = models.ChangeRequestFormAttachments
+        fields = '__all__'
+        read_only_fields = ['created', 'code']
+
+
+class ChangeRequestFormAttachmentsFileUploadSerializer(
+    serializers.ModelSerializer
+):
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        user_object = {
+            "id": instance.uploaded_by.id,
+            "name": instance.uploaded_by.name,
+            "username": instance.uploaded_by.username,
+            "code": instance.uploaded_by.code,
+            "email": instance.uploaded_by.email,
+            "contact_no": instance.uploaded_by.contact_no
+        }
+        ret['uploaded_by'] = user_object
+        return ret
+
+    class Meta:
+        model = models.ChangeRequestFormAttachments
+        fields = (
+            'id',
+            'code',
+            'attachment_type',
+            'attachment_name',
+            'file_name',
+            'description',
+            'file_upload',
+            'uploaded_by',
+            'form_code',
+            'created'
+        )
+        read_only_fields = ['id,', 'created', 'code']
\ No newline at end of file

app/applicationlayer/cms/form/attachment/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import ChangeRequestFormAttachments
+
+
+class AttachmentFilter(filters.FilterSet):
+
+    class Meta:
+        model = ChangeRequestFormAttachments
+        fields = '__all__'

app/applicationlayer/cms/form/attachment/views.py

+from app.entities import models
+from rest_framework import viewsets, status
+from rest_framework.response import Response
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.applicationlayer.cms.form.attachment.table_filters import AttachmentFilter
+from app.applicationlayer.cms.form.attachment import serializers
+from app.applicationlayer.utils import (
+    CustomPagination, status_message_response
+)
+
+
+class ChangeRequestFormAttachmentsViewset(viewsets.ModelViewSet):
+    # queryset = models.ChangeRequestFormAttachments.objects.all()
+    queryset = models.ChangeRequestFormAttachments.objects.select_related(
+        'form_code', 'file_upload'
+    ).all()
+    serializer_class = serializers.ChangeRequestFormAttachmentsSerializer
+    pagination_class = CustomPagination
+    lookup_field = "code"
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = AttachmentFilter
+    ordering_fields = '__all__'
+    search_fields = (
+        'form_code', 'code',
+        'file_name',
+        'description',
+        'uploaded_by__name'
+    )
+
+    def list(self, request, *args, **kwargs):
+        queryset = self.filter_queryset(self.get_queryset())
+        page = self.paginate_queryset(queryset)
+        
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Form Attachments found',
+                serializer.data
+            )
+            
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+    
+    def retrieve(self, request, *args, **kwargs):
+        instance = self.get_object()
+        serializer = self.get_serializer(instance)
+        return Response(serializer.data)
\ No newline at end of file

app/applicationlayer/cms/form/details/serializers.py

+from app.entities import models
+from rest_framework import serializers
+
+
+class ChangeRequestFormDetailsSerializer(
+    serializers.ModelSerializer
+):
+    class Meta:
+        model = models.ChangeRequestFormDetails
+        fields = '__all__'
+        read_only_fields = ['created', 'code']
\ No newline at end of file

app/applicationlayer/cms/form/details/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import ChangeRequestFormDetails
+
+
+class DetailsFilter(filters.FilterSet):
+
+    class Meta:
+        model = ChangeRequestFormDetails
+        fields = '__all__'

app/applicationlayer/cms/form/details/views.py

+from app.entities import models
+from rest_framework import viewsets, status
+from rest_framework.response import Response
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.applicationlayer.cms.form.details.table_filters import DetailsFilter
+from app.applicationlayer.cms.form.details import serializers
+from app.applicationlayer.utils import (
+    CustomPagination, status_message_response
+)
+
+
+class ChangeRequestFormDetailsViewset(viewsets.ModelViewSet):
+    
+    queryset = models.ChangeRequestFormDetails.objects.select_related(
+        'form_code'
+    ).all()
+    serializer_class = serializers.ChangeRequestFormDetailsSerializer
+    pagination_class = CustomPagination
+    lookup_field = "code"
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = DetailsFilter
+    ordering_fields = '__all__'
+    search_fields = (
+        'code', 'form_code'
+    )
+
+    def list(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.get_queryset())
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Form Details found',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+    
+    def retrieve(self, request, *args, **kwargs):
+        instance = self.get_object()
+        serializer = self.get_serializer(instance)
+        return Response(serializer.data)

app/applicationlayer/cms/form/download/serializers.py

+from app.entities import models
+from rest_framework import serializers
+from django.db.models import Q
+
+
+class headers(serializers.ModelSerializer):
+
+
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        # try:
+        user = self.context['request'].user
+        
+        id_number = user.code
+        
+        current_level = models.ChangeRequestFormApprovers.objects.filter(
+            Q(form_code=instance.form_code) &
+            (Q(action='') | Q(action=None))
+        ).order_by('level')
+        
+        if current_level.count() > 0 and current_level[0].user.code == id_number:
+            if instance.status.lower() == 'rejected':
+                approver = 'No'
+            elif instance.status.lower() == 'cancelled':
+                approver = 'No'
+            elif instance.status.lower() == 'completed & accepted':
+                approver = 'No'
+            else:
+                approver = 'Yes'
+        else:
+            approver = 'No'
+        
+        ret['requested_to_company'] = instance.requested_to_company.name
+        ret['requested_to_department'] = instance.requested_to_department.name
+        ret['requested_by_user'] = instance.requested_by_user.name
+        ret['requested_to_target_date'] = instance.requested_to_target_date.strftime('%Y-%m-%d-%H:%M:%S')
+        # ret['created'] = instance.created.strftime('%Y-%m-%d-%H:%M:%S')
+        ret['created'] = instance.created.strftime('%Y-%m-%d-%H:%M:%S')
+        ret['action'] = approver
+        # ret['requested_to_target_date'] = instance.requested_to_target_date.strftime('%Y-%m-%d-%H:%M:%S')
+        return ret
+        # except Exception as e:
+        #     ret['action_required'] = "No"
+        #     ret['company'] = "None"
+        #     ret['department'] = "None"
+        #     ret['requested_by'] = "None"
+
+        #     return ret
+
+
+    class Meta:
+        model = models.ChangeRequestFormHeader
+        fields = (
+            'requested_to_template_id',
+            'requested_to_template_name',
+            'requested_to_company',
+            'requested_to_department',
+            'requested_by_user',
+            'status',
+            'requested_to_priority',
+            # 'action',
+            'created',
+            'requested_to_target_date'
+        )

app/applicationlayer/cms/form/download/views.py

+from rest_framework.viewsets import ReadOnlyModelViewSet
+from drf_renderer_xlsx.mixins import XLSXFileMixin
+from drf_renderer_xlsx.renderers import XLSXRenderer
+from app.entities.models import (
+    ChangeRequestFormHeader,
+    AllowedCompany
+)
+from app.applicationlayer.cms.form.download.serializers import headers
+from django.db.models import Q
+from rest_framework.response import Response
+from rest_framework.permissions import AllowAny
+
+
+class DownloadRequest(XLSXFileMixin, ReadOnlyModelViewSet):
+    queryset = ChangeRequestFormHeader.objects.all()
+    serializer_class = headers
+    renderer_classes = (XLSXRenderer,)
+    filename = 'Change Request Form.xlsx'
+    permission_classes = (AllowAny,)
+
+    def list(self, request, *args, **kwargs):
+        id_number = request.user.code
+        # data = ChangeRequestFormHeader.objects.filter(
+        #     Q(frm_approvers__user__code=id_number) |
+        #     Q(requested_by_user=id_number) |
+        #     Q(frm_stakes__user__code=id_number)
+        # ).distinct()
+
+
+        priviledgeCrs = AllowedCompany.objects.filter(
+            Q(id_number=id_number) &
+            Q(view_all_change_request=True)
+        ).values('group_pivots')
+        
+        data = ChangeRequestFormHeader.objects.filter(
+            (Q(frm_approvers__user__code=id_number) |
+            Q(frm_stakes__user__code=id_number) |
+            Q(requested_by_user=id_number) |
+            Q(requested_to_department__in=priviledgeCrs)) &
+            Q(is_active=True)
+        ).exclude(
+                Q(status__icontains='Draft') &
+                ~Q(requested_by_user=id_number)
+        ).distinct()
+
+        serializer = headers(data=data, many=True, context={'request': request})
+        serializer.is_valid(raise_exception=False)
+        return Response(serializer.data)
+
+    column_header = {
+        'titles': [
+            "Cr Number",
+            "Name",
+            "Company Request To",
+            "Department Requested To",
+            "Requested By",
+            "Status",
+            "Priority Level",
+            "Date Modified",
+            "Date Required"
+            "Action",
+        ],
+        'column_width': [17, 30, 17],
+        'height': 25,
+        'style': {
+            'alignment': {
+                'horizontal': 'center',
+                'vertical': 'center',
+                'wrapText': False,
+                'shrink_to_fit': True,
+            },
+            'border_side': {
+                'border_style': 'thin',
+                'color': 'FF000000',
+            },
+            'font': {
+                'name': 'Arial',
+                'size': 14,
+                'bold': True,
+                'color': 'FF000000',
+            },
+        },
+    }

app/applicationlayer/cms/form/header/serializers.py

+from app.entities import models
+from rest_framework import serializers
+from app.applicationlayer.utils import model_to_dict
+from django.db.models import Q
+
+from app.applicationlayer.cms.form.approver.serializers import ChangeRequestFormApproversSerializer
+from app.applicationlayer.cms.form.stakeholder.serializers import ChangeRequestFormStakeHoldersSerializer
+from app.applicationlayer.cms.form.details.serializers import ChangeRequestFormDetailsSerializer
+from app.applicationlayer.cms.form.attachment.serializers import ChangeRequestFormAttachmentsSerializer
+
+
+class ChangeRequestFormHeaderSerializer(
+    serializers.ModelSerializer
+):
+    frm_approvers = ChangeRequestFormApproversSerializer(
+        many=True, read_only=True)
+    frm_stakes = ChangeRequestFormStakeHoldersSerializer(
+        many=True, read_only=True)
+    frm_attachments = ChangeRequestFormAttachmentsSerializer(
+        many=True, read_only=True)
+    frm_details = ChangeRequestFormDetailsSerializer(
+        many=True, read_only=True)
+    
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        try:
+            user = self.context['request'].user
+            
+            id_number = user.code
+            
+            current_level = models.ChangeRequestFormApprovers.objects.filter(
+                Q(form_code=ret['form_code']) &
+                Q(is_action=True) &
+                Q(user=id_number)
+            ).order_by('level')
+            
+            if current_level.count() > 0: # and current_level[0].user.code == id_number
+                if instance.status.lower() == 'rejected':
+                    approver = 'No'
+                elif instance.status.lower() == 'cancelled':
+                    approver = 'No'
+                elif instance.status.lower() == 'completed & accepted':
+                    approver = 'No'
+                else:
+                    approver = 'Yes'
+            else:
+                approver = 'No'
+            
+            ret['action_required'] = approver
+            
+            requested_to_user = {
+                "id": instance.requested_to_user.id,
+                "name": instance.requested_to_user.name,
+                "username": instance.requested_to_user.username,
+                "code": instance.requested_to_user.code,
+                "email": instance.requested_to_user.email,
+                "contact_no": instance.requested_to_user.contact_no
+            }
+
+            requested_by_user = {
+                "id": instance.requested_by_user.id,
+                "name": instance.requested_by_user.name,
+                "username": instance.requested_by_user.username,
+                "code": instance.requested_by_user.code,
+                "email": instance.requested_by_user.email,
+                "contact_no": instance.requested_by_user.contact_no
+            }
+
+            # ret['requested_to_company'] = model_to_dict(instance.requested_to_company)
+            ret['requested_to_company'] = {
+                "id": instance.requested_to_company.id,
+                "code": instance.requested_to_company.code,
+                "name": instance.requested_to_company.name
+            }
+            # ret['requested_to_department'] = model_to_dict(instance.requested_to_department)
+            ret['requested_to_department'] = {
+                "id": instance.requested_to_department.id,
+                "code": instance.requested_to_department.code,
+                "name": instance.requested_to_department.name
+            }
+            ret['requested_to_user'] = requested_to_user
+            ret['requested_by_user'] = requested_by_user
+            ret['requested_by_department'] = {
+                "id": instance.requested_by_department.id,
+                "code": instance.requested_by_department.code,
+                "name": instance.requested_by_department.name
+            }
+            ret['template_object'] = model_to_dict(instance.template_no)
+            
+            return ret
+        except Exception as e:
+            ret['action_required'] = "None"
+            ret['requested_to_company'] = "None"
+            ret['requested_to_department'] = "None"
+            ret['requested_to_user'] = "None"
+            ret['requested_by_user'] = "None"
+            ret['requested_by_department'] = "None"
+            ret['template_object'] = "None"
+
+            return ret
+    
+    class Meta:
+        model = models.ChangeRequestFormHeader
+        # fields = '__all__'
+        fields = ('form_code', 'requested_to_template_name', 'requested_to_objective',
+                  'requested_to_target_date', 'requested_to_priority',
+                  'description', 'created', 'cancel_date', 'status',
+                  'requested_to_template_id', 'requested_to_company',
+                  'requested_to_department', 'requested_to_user',
+                  'requested_by_user', 'requested_by_department',
+                  'template_no', 'frm_approvers', 'frm_stakes',
+                  'frm_attachments', 'frm_details')
+
+        read_only_fields = ['created', 'form_code']
+
+
+class ChangeRequestFormHeaderSerializerList(
+    serializers.ModelSerializer
+):
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        try:
+            user = self.context['request'].user
+            
+            id_number = user.code
+            
+            current_level = models.ChangeRequestFormApprovers.objects.filter(
+                Q(form_code=ret['form_code']) &
+                Q(is_action=True) &
+                Q(user=id_number)
+            ).order_by('level')
+            
+            if current_level.count() > 0: # and current_level[0].user.code == id_number
+                if instance.status.lower() == 'rejected':
+                    approver = 'No'
+                elif instance.status.lower() == 'cancelled':
+                    approver = 'No'
+                elif instance.status.lower() == 'completed & accepted':
+                    approver = 'No'
+                else:
+                    approver = 'Yes'
+            else:
+                approver = 'No'
+            
+            ret['action_required'] = approver
+            ret['company'] = instance.requested_to_company.name
+            ret['department'] = instance.requested_to_department.name
+            ret['requested_by'] = instance.requested_by_user.name
+
+            if instance.status.lower() == 'draft':
+                existing_transaction = models.ChangeRequestHistory.objects.filter(
+                    form_code=instance.form_code
+                )
+                if existing_transaction.count() > 0:
+                    can_delete = False
+                else:
+                    can_delete = True  # hard delete
+
+            elif instance.status.lower() == 'cancelled':
+                can_delete = False
+            else:
+                can_delete = None
+
+            ret['can_delete'] = can_delete
+
+            return ret
+        except Exception as e:
+            ret['action_required'] = "No"
+            ret['company'] = "None"
+            ret['department'] = "None"
+            ret['requested_by'] = "None"
+
+            return ret
+
+    class Meta:
+        model = models.ChangeRequestFormHeader
+        fields = '__all__'
+        read_only_fields = ['created', 'form_code']
\ No newline at end of file

app/applicationlayer/cms/form/header/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import ChangeRequestFormHeader
+
+
+class HeaderFilterSet(filters.FilterSet):
+
+    # action_required = filters.CharFilter(method='action_required_bar')
+    
+    class Meta:
+        model = ChangeRequestFormHeader
+        fields = '__all__'
+
+    # def action_required_bar(self, queryset, name, value):
+    #     return queryset.filter(
+    #         Q(title__icontains=value) |
+    #         Q(name__icontains=value) |
+    #         Q(description__icontains=value)
+    #     )

app/applicationlayer/cms/form/onbehalf/serializers.py

+from app.entities import models
+from rest_framework import serializers
+from app.applicationlayer.utils import model_to_dict
+from django.db.models import Q
+
+from app.applicationlayer.cms.form.approver.serializers import ChangeRequestFormApproversSerializer
+from app.applicationlayer.cms.form.stakeholder.serializers import ChangeRequestFormStakeHoldersSerializer
+from app.applicationlayer.cms.form.details.serializers import ChangeRequestFormDetailsSerializer
+from app.applicationlayer.cms.form.attachment.serializers import ChangeRequestFormAttachmentsSerializer
+
+
+class ChangeRequestFormHeaderSerializer(
+    serializers.ModelSerializer
+):
+    frm_approvers = ChangeRequestFormApproversSerializer(
+        many=True, read_only=True)
+    frm_stakes = ChangeRequestFormStakeHoldersSerializer(
+        many=True, read_only=True)
+    frm_attachments = ChangeRequestFormAttachmentsSerializer(
+        many=True, read_only=True)
+    frm_details = ChangeRequestFormDetailsSerializer(
+        many=True, read_only=True)
+    
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        try:
+            user = self.context['request'].user
+            
+            id_number = user.code
+            
+            current_level = models.ChangeRequestFormApprovers.objects.filter(
+                Q(form_code=ret['form_code']) &
+                Q(is_action=True) &
+                Q(user=id_number)
+            ).order_by('level')
+            
+            if current_level.count() > 0: # and current_level[0].user.code == id_number
+                if instance.status.lower() == 'rejected':
+                    approver = 'No'
+                elif instance.status.lower() == 'cancelled':
+                    approver = 'No'
+                elif instance.status.lower() == 'completed & accepted':
+                    approver = 'No'
+                else:
+                    approver = 'Yes'
+            else:
+                approver = 'No'
+            
+            ret['action_required'] = approver
+            
+            requested_to_user = {
+                "id": instance.requested_to_user.id,
+                "name": instance.requested_to_user.name,
+                "username": instance.requested_to_user.username,
+                "code": instance.requested_to_user.code,
+                "email": instance.requested_to_user.email,
+                "contact_no": instance.requested_to_user.contact_no
+            }
+
+            requested_by_user = {
+                "id": instance.requested_by_user.id,
+                "name": instance.requested_by_user.name,
+                "username": instance.requested_by_user.username,
+                "code": instance.requested_by_user.code,
+                "email": instance.requested_by_user.email,
+                "contact_no": instance.requested_by_user.contact_no
+            }
+
+            ret['requested_to_company'] = {
+                "id": instance.requested_to_company.id,
+                "code": instance.requested_to_company.code,
+                "name": instance.requested_to_company.name
+            }
+
+            ret['requested_to_department'] = {
+                "id": instance.requested_to_department.id,
+                "code": instance.requested_to_department.code,
+                "name": instance.requested_to_department.name
+            }
+            ret['requested_to_user'] = requested_to_user
+            ret['requested_by_user'] = requested_by_user
+            ret['requested_by_department'] = {
+                "id": instance.requested_by_department.id,
+                "code": instance.requested_by_department.code,
+                "name": instance.requested_by_department.name
+            }
+            ret['template_object'] = model_to_dict(instance.template_no)
+            
+            return ret
+        except Exception as e:
+            ret['action_required'] = "None"
+            ret['requested_to_company'] = "None"
+            ret['requested_to_department'] = "None"
+            ret['requested_to_user'] = "None"
+            ret['requested_by_user'] = "None"
+            ret['requested_by_department'] = "None"
+            ret['template_object'] = "None"
+
+            return ret
+    
+    class Meta:
+        model = models.ChangeRequestFormHeader
+        fields = ('form_code', 'requested_to_template_name', 'requested_to_objective',
+                  'requested_to_target_date', 'requested_to_priority',
+                  'description', 'created', 'cancel_date', 'status',
+                  'requested_to_template_id', 'requested_to_company',
+                  'requested_to_department', 'requested_to_user',
+                  'requested_by_user', 'requested_by_department',
+                  'template_no', 'frm_approvers', 'frm_stakes',
+                  'frm_attachments', 'frm_details')
+
+        read_only_fields = ['created', 'form_code']
+
+
+class ChangeRequestFormHeaderSerializerList(
+    serializers.ModelSerializer
+):
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        try:
+            user = self.context['request'].user
+            
+            id_number = user.code
+
+            active_users = models.ChangeRequestSettings.objects.filter(
+                behalf_user=id_number).values('active_user__code')
+            
+            current_level = models.ChangeRequestFormApprovers.objects.filter(
+                Q(form_code=ret['form_code']) &
+                Q(is_action=True) &
+                Q(user__in=active_users)
+            ).order_by('level')
+            
+            if current_level.count() > 0:
+                if instance.status.lower() == 'rejected':
+                    approver = 'No'
+                elif instance.status.lower() == 'cancelled':
+                    approver = 'No'
+                elif instance.status.lower() == 'completed & accepted':
+                    approver = 'No'
+                else:
+                    approver = 'Yes'
+            else:
+                approver = 'No'
+            
+            ret['action_required'] = approver
+            ret['company'] = instance.requested_to_company.name
+            ret['department'] = instance.requested_to_department.name
+            ret['requested_by'] = instance.requested_by_user.name
+
+            if instance.status.lower() == 'draft':
+                existing_transaction = models.ChangeRequestHistory.objects.filter(
+                    form_code=instance.form_code
+                )
+                if existing_transaction.count() > 0:
+                    can_delete = False
+                else:
+                    can_delete = True  # hard delete
+
+            elif instance.status.lower() == 'cancelled':
+                can_delete = False
+            else:
+                can_delete = None
+
+            ret['can_delete'] = can_delete
+
+            return ret
+        except Exception as e:
+            ret['action_required'] = "No"
+            ret['company'] = "None"
+            ret['department'] = "None"
+            ret['requested_by'] = "None"
+
+            return ret
+
+    class Meta:
+        model = models.ChangeRequestFormHeader
+        fields = '__all__'
+        read_only_fields = ['created', 'form_code']
\ No newline at end of file

app/applicationlayer/cms/form/onbehalf/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import ChangeRequestFormHeader
+
+
+class HeaderFilterSet(filters.FilterSet):
+    
+    class Meta:
+        model = ChangeRequestFormHeader
+        fields = '__all__'
\ No newline at end of file

app/applicationlayer/cms/form/onbehalf/views.py

+import os
+from rest_framework import viewsets
+from app.entities import models
+
+from rest_framework.response import Response
+from rest_framework import status, views
+
+from django.db.models import Q
+from app.applicationlayer.utils import (QuerySetHelper,
+                                        status_message_response)
+from app.businesslayer.changerequest import change_request
+
+from app.entities import enums
+from app.applicationlayer.utils import (CustomPagination,
+                                        status_message_response)
+
+from app.applicationlayer.cms.form.onbehalf.serializers import (
+    ChangeRequestFormHeaderSerializer,
+    ChangeRequestFormHeaderSerializerList)
+from app.applicationlayer.cms.form.onbehalf.table_filters import HeaderFilterSet
+
+from rest_framework.filters import SearchFilter, OrderingFilter
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+
+
+class ChangeRequestFormsViewset(viewsets.ModelViewSet):
+
+    queryset = models.ChangeRequestFormHeader.objects.select_related(
+        'requested_by_user', 'requested_by_department', 'template_no'
+    ).all()
+    serializer_class = ChangeRequestFormHeaderSerializer
+    pagination_class = CustomPagination
+    lookup_field = 'form_code'
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = HeaderFilterSet
+    ordering_fields = (
+        'form_code',
+        'requested_to_template_id',
+        'requested_to_user__name',
+        'requested_to_department__company__name',
+        'requested_to_department__name',
+        'requested_by_user__name',
+        'status',
+        'requested_to_priority',
+        'created',
+        'requested_to_target_date'
+    )
+
+    search_fields = (
+        "form_code", "status", "requested_to_template_id", "requested_by_user__name",
+        "requested_by_user__code", "requested_by_department__name",
+        "requested_to_company__name", "requested_to_department__name",
+        "requested_to_user__name", "requested_to_template_name",
+        "requested_to_objective", "requested_to_priority", "description"
+    )
+
+    def list(self, request, *args, **kwargs):
+        
+        self.serializer_class = ChangeRequestFormHeaderSerializerList
+        
+        behalf_user = self.request.user.code
+
+        user_active_included = []
+        active_users = models.ChangeRequestSettings.objects.filter(
+            behalf_user=behalf_user)
+        
+        for active_user in active_users:
+            user_active_included.append(active_user.active_user.code)
+
+        self.queryset = change_request.list_by_onbehalf_without_dept(
+            user_active_included)
+        
+        self.queryset = change_request.filter_onbehalf_crlist(
+            self.queryset,
+            user_active_included)
+        
+        # self.queryset = change_request.filter_base(
+        #     self.queryset,
+        #     request.query_params.get('company_requested_to'),
+        #     request.query_params.get('department_requested_to'),
+        #     request.query_params.get('date_modified_from'),
+        #     request.query_params.get('date_modified_to'),
+        #     request.query_params.get('date_required_from'),
+        #     request.query_params.get('date_required_to'),
+        #     request.query_params.get('form_type'),
+        # )
+        
+        queryset = self.filter_queryset(self.queryset)
+
+        page = self.paginate_queryset(queryset)
+        
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Change Request Forms for on behalf found',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+            
+    def retrieve(self, request, *args, **kwargs):
+        id_number = self.request.user.code
+        form_code = kwargs['form_code']
+
+        instance = self.get_object()
+        serializer = self.get_serializer(instance)
+        
+        return Response(serializer.data)

app/applicationlayer/cms/form/stakeholder/serializers.py

+from app.entities import models
+from rest_framework import serializers
+from app.applicationlayer.utils import model_to_dict
+
+
+class ChangeRequestFormStakeHoldersSerializer(
+    serializers.ModelSerializer
+):
+    def to_representation(self, instance):
+        try:
+            ret = super().to_representation(instance)
+            user_object = {
+                "id": instance.user.id,
+                "name": instance.user.name,
+                "username": instance.user.username,
+                "code": instance.user.code,
+                "email": instance.user.email,
+                "contact_no": instance.user.contact_no
+            }
+            ret['company'] = model_to_dict(instance.user.department.company)
+            ret['department'] = model_to_dict(instance.user.department)
+            ret['user'] = user_object
+
+            return ret
+        except Exception as e:
+            ret['company'] = "none"
+            ret['department'] = "none"
+            ret['name'] = "none"
+            return ret
+
+    class Meta:
+        model = models.ChangeRequestFormStakeHolders
+        fields = '__all__'
+        read_only_fields = ['created', 'code']
\ No newline at end of file

app/applicationlayer/cms/form/stakeholder/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import ChangeRequestFormStakeHolders
+
+
+class StakeHolderFilter(filters.FilterSet):
+
+    class Meta:
+        model = ChangeRequestFormStakeHolders
+        fields = '__all__'

app/applicationlayer/cms/form/stakeholder/views.py

+from app.entities import models
+from rest_framework import viewsets, status
+from rest_framework.response import Response
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.applicationlayer.cms.form.stakeholder.table_filters import StakeHolderFilter
+from app.applicationlayer.cms.form.stakeholder import serializers
+from app.applicationlayer.utils import (
+    CustomPagination, status_message_response
+)
+
+
+class ChangeRequestFormStakeHoldersViewset(viewsets.ModelViewSet):
+   
+    queryset = models.ChangeRequestFormStakeHolders.objects.select_related(
+        'form_code'
+    ).all()
+    serializer_class = serializers.ChangeRequestFormStakeHoldersSerializer
+    pagination_class = CustomPagination
+    lookup_field = "code"
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = StakeHolderFilter
+    ordering_fields = '__all__'
+    search_fields = (
+        'name', 'code',
+        'department__company__name',
+        'department__name',
+        'email', 'contact_no'
+    )
+
+    def list(self, request, *args, **kwargs):
+        queryset = self.filter_queryset(self.get_queryset())
+        
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Templates Stakeholders found',
+                serializer.data
+            )
+
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )
+
+    def retrieve(self, request, *args, **kwargs):
+        instance = self.get_object()
+        serializer = self.get_serializer(instance)
+        return Response(serializer.data)
\ No newline at end of file

app/applicationlayer/cms/master/form/account/views.py

+from rest_framework.views import APIView
+from app.applicationlayer.utils import (CustomPagination,
+                                        status_message_response)
+from app.applicationlayer.management.account.serializer import ChangeRequestList
+from app.entities import models
+from rest_framework.response import Response
+from rest_framework import status
+
+
+class UserListForm(APIView):
+
+    pagination_class = CustomPagination
+
+    def get(self, request, *args, **kwargs):
+
+        try:
+            serializer = ChangeRequestList
+            dept = self.request.query_params['department_code']
+            user_list = models.User.objects.filter(
+                department=dept
+            ).exclude(id=1)
+            
+            page = self.paginate_queryset(user_list)
+
+            if page is not None:
+
+                serializer = ChangeRequestList(page, many=True)
+
+                message = status_message_response(
+                    200,
+                    'success',
+                    'list of User found',
+                    serializer.data
+                )
+                return self.get_paginated_response(message)
+        except Exception as e:
+            return Response(
+                {"message": "this endpoint expect a query params department_id"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+    @property
+    def paginator(self):
+        """
+        The paginator instance associated with the view, or `None`.
+        """
+        if not hasattr(self, '_paginator'):
+            if self.pagination_class is None:
+                self._paginator = None
+            else:
+                self._paginator = self.pagination_class()
+        return self._paginator
+
+    def paginate_queryset(self, queryset):
+        """
+        Return a single page of results, or `None` if pagination is disabled.
+        """
+        if self.paginator is None:
+            return None
+        return self.paginator.paginate_queryset(queryset, self.request, view=self)
+
+    def get_paginated_response(self, data):
+        """
+        Return a paginated style `Response` object for the given output data.
+        """
+        assert self.paginator is not None
+        return self.paginator.get_paginated_response(data)
\ No newline at end of file

app/applicationlayer/cms/master/form/company/serializer.py

+from rest_framework import serializers
+from app.entities.models import Company
+
+
+class AdminCompanySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Company
+        fields = '__all__'

app/applicationlayer/cms/master/form/company/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import Company
+from django.db.models import Q
+
+
+class ChangeRequestCompanyFilterSet(filters.FilterSet):
+    # search = filters.CharFilter(method='search_bar', label='search')
+    # def search_bar(self, queryset, name, value):
+    #     return queryset.filter(
+    #         Q(Companyname__icontains=value) |
+    #         Q(first_name__icontains=value) |
+    #         Q(last_name__icontains=value))
+
+    class Meta:
+        model = Company
+        fields = '__all__'

app/applicationlayer/cms/master/form/company/views.py

+from django_filters import rest_framework as filters
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.entities.models import (
+    Company, AllowedCompany,
+    ChangeRequestFormHeader
+)
+from rest_framework import viewsets
+from app.businesslayer.company.serializer import AdminCompanySerializer
+from app.applicationlayer.utils import (CustomPagination,
+                                        status_message_response)
+from django_filters.rest_framework import DjangoFilterBackend
+from app.applicationlayer.management.company import serializer
+from app.applicationlayer.cms.master.form.company.table_filters import (
+    ChangeRequestCompanyFilterSet
+)
+from rest_framework.response import Response
+from django.db.models import Q
+from rest_framework.decorators import action
+
+
+class ChangeRequestCompanyFormViewSet(viewsets.ModelViewSet):
+    queryset = Company.objects.all()
+    serializer_class = AdminCompanySerializer
+    pagination_class = CustomPagination
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = ChangeRequestCompanyFilterSet
+    ordering_fields = '__all__'
+    search_fields = ('name',)
+    http_method_names = ['get']
+
+    def list(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.get_queryset())
+        allowed = AllowedCompany.objects.filter(
+            Q(id_number=self.request.user.code) &
+            Q(create_change_request=True)
+        ).values('company_pivot')
+        queryset = queryset.filter(code__in=allowed)
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'list of Company found',
+                serializer.data
+            )
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(queryset, many=True)
+        return Response(serializer.data)
+
+
+    @action(
+        methods=['GET'], detail=False,
+        url_path='filter', url_name='filter'
+    )
+    def filter(self, request, *args, **kwargs):
+
+        # instance = self.get_object()
+        # list_his = []
+
+        queryset = self.filter_queryset(self.get_queryset())
+
+
+        id_number = request.user.code
+
+        forms = ChangeRequestFormHeader.objects.filter(
+            Q(frm_approvers__user__code=id_number) |
+            Q(requested_by_user=id_number) |
+            Q(frm_stakes__user__code=id_number)
+        ).values()
+        
+        allowed = AllowedCompany.objects.filter(
+            id_number=id_number
+        ).values().distinct()
+
+        forms = [data['requested_to_company_id'] for data in forms]
+        allowed = [data['company_pivot_id'] for data in allowed]
+
+        forms = forms + allowed
+        if len(forms) == 0:
+            queryset = queryset.filter(id=0)
+        else:
+            queryset = queryset.filter(code__in=forms)
+    
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'list of Company found',
+                serializer.data
+            )
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(queryset, many=True)
+        return Response(serializer.data)

app/applicationlayer/cms/master/form/department/serializer.py

+from rest_framework import serializers
+from app.entities.models import Department
+from app.applicationlayer.utils import model_to_dict
+
+
+class AdminDepartmentSerializer(serializers.ModelSerializer):
+
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        ret['company'] = model_to_dict(instance.company)
+        return ret
+
+    class Meta:
+        model = Department
+        fields = '__all__'
+        read_only_fields = (
+            'created', 'createdby', 'modified', 'modifiedby', 'code',
+        )
\ No newline at end of file

app/applicationlayer/cms/master/form/department/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import Department
+from django.db.models import Q
+
+
+class ChangeRequestDepartmentFilterSet(filters.FilterSet):
+    # search = filters.CharFilter(method='search_bar', label='search')
+    # def search_bar(self, queryset, name, value):
+    #     return queryset.filter(
+    #         Q(Companyname__icontains=value) |
+    #         Q(first_name__icontains=value) |
+    #         Q(last_name__icontains=value))
+
+    class Meta:
+        model = Department
+        fields = '__all__'

app/applicationlayer/cms/master/form/department/views.py

+from rest_framework import viewsets
+from rest_framework.response import Response
+from rest_framework.filters import SearchFilter, OrderingFilter
+from django_filters import rest_framework as filters
+from app.entities.models import Department, AllowedCompany
+from app.applicationlayer.utils import (
+    CustomPagination, status_message_response
+)
+from django_filters.rest_framework import DjangoFilterBackend
+from app.applicationlayer.master.department import serializer
+from app.applicationlayer.cms.master.form.department.table_filters import (
+    ChangeRequestDepartmentFilterSet
+)
+from django.db.models import Q
+
+
+class ChangeRequestDepartmentFormViewSet(viewsets.ModelViewSet):
+    queryset = Department.objects.all()
+    serializer_class = serializer.AdminDepartmentSerializer
+    pagination_class = CustomPagination
+    lookup_field = 'code'
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = ChangeRequestDepartmentFilterSet
+    ordering_fields = '__all__'
+    search_fields = ('name', 'company__name', 'code')
+
+    # @rms.department_list
+    def list(self, request, *args, **kwargs):
+        company = self.request.query_params['company_code']
+        queryset = self.filter_queryset(self.get_queryset())
+        allowed = AllowedCompany.objects.filter(
+            Q(id_number=self.request.user.code) &
+            Q(company_pivot=company) &
+            Q(create_change_request=True)
+        ).values('group_pivots')
+        queryset = queryset.filter(code__in=allowed)
+        page = self.paginate_queryset(queryset)
+        
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'list of Department found',
+                serializer.data
+            )
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(queryset, many=True)
+        return Response(serializer.data)
+
+
+
+
+

app/applicationlayer/cms/master/template/account/views.py

+from rest_framework.views import APIView
+from app.applicationlayer.utils import (CustomPagination,
+                                        status_message_response)
+from app.applicationlayer.management.account.serializer import ChangeRequestList
+from app.entities import models
+from django.db.models import Q
+
+
+class UserListTemplate(APIView):
+
+    pagination_class = CustomPagination
+
+    def get(self, request, *args, **kwargs):
+        # try:
+            serializer = ChangeRequestList
+            dept = self.request.query_params['department_code']
+            
+            verified_users = models.AllowedCompany.objects.filter(
+                Q(group_pivots=dept) &
+                Q(create_change_request_template=True)
+            ).values_list('id_number')
+
+            user_list = models.User.objects.filter(
+                code__in=verified_users
+            )
+            page = self.paginate_queryset(user_list)
+
+            if page is not None:
+
+                serializer = ChangeRequestList(page, many=True)
+
+                message = status_message_response(
+                    200,
+                    'success',
+                    'list of User found',
+                    serializer.data
+                )
+            return self.get_paginated_response(message)
+
+        # except Exception as e:
+        #     return Response(
+        #         {"message": "this endpoint expect a query params department_id"},
+        #         status=status.HTTP_400_BAD_REQUEST
+        #     )
+
+    @property
+    def paginator(self):
+        """
+        The paginator instance associated with the view, or `None`.
+        """
+        if not hasattr(self, '_paginator'):
+            if self.pagination_class is None:
+                self._paginator = None
+            else:
+                self._paginator = self.pagination_class()
+        return self._paginator
+
+    def paginate_queryset(self, queryset):
+        """
+        Return a single page of results, or `None` if pagination is disabled.
+        """
+        if self.paginator is None:
+            return None
+        return self.paginator.paginate_queryset(queryset, self.request, view=self)
+
+    def get_paginated_response(self, data):
+        """
+        Return a paginated style `Response` object for the given output data.
+        """
+        assert self.paginator is not None
+        return self.paginator.get_paginated_response(data)
\ No newline at end of file

app/applicationlayer/cms/master/template/company/serializer.py

+from rest_framework import serializers
+from app.entities.models import Company
+
+
+class AdminCompanySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Company
+        fields = '__all__'

app/applicationlayer/cms/master/template/company/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import Company
+from django.db.models import Q
+
+
+class ChangeRequestCompanyFilterSet(filters.FilterSet):
+    # search = filters.CharFilter(method='search_bar', label='search')
+    # def search_bar(self, queryset, name, value):
+    #     return queryset.filter(
+    #         Q(Companyname__icontains=value) |
+    #         Q(first_name__icontains=value) |
+    #         Q(last_name__icontains=value))
+
+    class Meta:
+        model = Company
+        fields = '__all__'

app/applicationlayer/cms/master/template/company/views.py

+from rest_framework.filters import SearchFilter, OrderingFilter
+from django_filters import rest_framework as filters
+from app.entities.models import Company, AllowedCompany
+from rest_framework import viewsets
+from app.businesslayer.company.serializer import AdminCompanySerializer
+from app.applicationlayer.utils import CustomPagination, status_message_response
+from django_filters.rest_framework import DjangoFilterBackend
+from app.applicationlayer.management.company import serializer
+from app.applicationlayer.cms.master.template.company.table_filters import (
+    ChangeRequestCompanyFilterSet
+)
+from rest_framework.response import Response
+from django.db.models import Q
+
+
+class ChangeRequestCompanyTemplateViewSet(viewsets.ModelViewSet):
+    queryset = Company.objects.all()
+    serializer_class = AdminCompanySerializer
+    pagination_class = CustomPagination
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = ChangeRequestCompanyFilterSet
+    ordering_fields = '__all__'
+    search_fields = ('name',)
+    http_method_names = ['get']
+
+    def list(self, request, *args, **kwargs):
+
+        queryset = self.filter_queryset(self.get_queryset())
+        allowed = AllowedCompany.objects.filter(
+            Q(id_number=self.request.user.code) &
+            Q(create_change_request_template=True)
+        ).values('company_pivot')
+        queryset = queryset.filter(code__in=allowed)
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'list of Company found',
+                serializer.data
+            )
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(queryset, many=True)
+        return Response(serializer.data)

app/applicationlayer/cms/master/template/default_approver/serializer.py

+from rest_framework import serializers
+from app.entities.models import User
+from app.applicationlayer.utils import model_to_dict
+
+
+class DefaultApproverSerializer(serializers.ModelSerializer):
+
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        ret['department'] = model_to_dict(instance.department)
+        ret['company'] = model_to_dict(instance.department.company)
+        
+        return ret
+
+    class Meta:
+        model = User
+        fields = ('id', 'code', 'name', 'contact_no', 'email', 'department')
+        # fields = '__all__'
+        read_only_fields = (
+            'created', 'createdby', 'modified', 'modifiedby', 'code',
+        )
\ No newline at end of file

app/applicationlayer/cms/master/template/default_approver/table_filter.py

+from django_filters import rest_framework as filters
+from app.entities.models import User
+
+
+class DefaultApproverFilterSet(filters.FilterSet):
+    
+    class Meta:
+        model = User
+        fields = '__all__'

app/applicationlayer/cms/master/template/default_approver/views.py

+from rest_framework import viewsets
+from rest_framework.response import Response
+from rest_framework.filters import SearchFilter, OrderingFilter
+from django_filters import rest_framework as filters
+from app.entities.models import User, AllowedCompany
+from app.applicationlayer.utils import (
+    CustomPagination, status_message_response
+)
+
+from django_filters.rest_framework import DjangoFilterBackend
+from app.applicationlayer.cms.master.template.default_approver import serializer
+from app.applicationlayer.cms.master.template.default_approver.table_filter import (
+    DefaultApproverFilterSet
+)
+from django.db.models import Q
+
+
+class DefaultApproverViewSet(viewsets.ModelViewSet):
+    queryset = User.objects.all()
+    serializer_class = serializer.DefaultApproverSerializer
+    pagination_class = CustomPagination
+    lookup_field = 'code'
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = DefaultApproverFilterSet
+    ordering_fields = '__all__'
+    search_fields = ('name', 'department__name', 'code')
+    
+    def list(self, request, *args, **kwargs):
+        department = self.request.query_params['department_code']
+        queryset = self.filter_queryset(self.get_queryset())
+        default_user = AllowedCompany.objects.filter(
+            Q(group_pivots=department) &
+            Q(approve_cr=True)
+        ).values('id_number')
+        queryset = queryset.filter(code__in=default_user)
+        page = self.paginate_queryset(queryset)
+        
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'list of Default Approvers found',
+                serializer.data
+            )
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(queryset, many=True)
+        return Response(serializer.data)

app/applicationlayer/cms/master/template/department/serializer.py

+from rest_framework import serializers
+from app.entities.models import Department
+from app.applicationlayer.utils import model_to_dict
+
+
+class AdminDepartmentSerializer(serializers.ModelSerializer):
+
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        ret['company'] = model_to_dict(instance.company)
+        return ret
+    
+    class Meta:
+        model = Department
+        fields = '__all__'
+        read_only_fields = (
+            'created', 'createdby', 'modified', 'modifiedby', 'code',
+        )

app/applicationlayer/cms/master/template/department/table_filters.py

+from django_filters import rest_framework as filters
+from app.entities.models import Department
+from django.db.models import Q
+
+
+class ChangeRequestDepartmentFilterSet(filters.FilterSet):
+    # search = filters.CharFilter(method='search_bar', label='search')
+    # def search_bar(self, queryset, name, value):
+    #     return queryset.filter(
+    #         Q(Companyname__icontains=value) |
+    #         Q(first_name__icontains=value) |
+    #         Q(last_name__icontains=value))
+
+    class Meta:
+        model = Department
+        fields = '__all__'

app/applicationlayer/cms/master/template/department/views.py

+from rest_framework import viewsets
+from rest_framework.response import Response
+from rest_framework.filters import SearchFilter, OrderingFilter
+from django_filters import rest_framework as filters
+from app.entities.models import Department, AllowedCompany
+from app.applicationlayer.utils import (
+    CustomPagination, status_message_response
+)
+
+from django_filters.rest_framework import DjangoFilterBackend
+from app.applicationlayer.master.department import serializer
+from app.applicationlayer.cms.master.template.department.table_filters import (
+    ChangeRequestDepartmentFilterSet
+)
+from django.db.models import Q
+
+
+class ChangeRequestDepartmentTemplateViewSet(viewsets.ModelViewSet):
+    queryset = Department.objects.all()
+    serializer_class = serializer.AdminDepartmentSerializer
+    pagination_class = CustomPagination
+    lookup_field = 'code'
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = ChangeRequestDepartmentFilterSet
+    ordering_fields = '__all__'
+    search_fields = ('name', 'company__name', 'code')
+
+    # @rms.department_list
+    def list(self, request, *args, **kwargs):
+        company = self.request.query_params['company_code']
+        queryset = self.filter_queryset(self.get_queryset())
+        allowed = AllowedCompany.objects.filter(
+            Q(id_number=self.request.user.code) &
+            Q(company_pivot=company) &
+            Q(create_change_request_template=True)
+        ).values('group_pivots')
+        queryset = queryset.filter(code__in=allowed)
+        page = self.paginate_queryset(queryset)
+
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'list of Department found',
+                serializer.data
+            )
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(queryset, many=True)
+        return Response(serializer.data)

app/applicationlayer/cms/master/template_list/serializers.py

+from app.entities import models
+from rest_framework import serializers
+
+class ChangeRequestTemplatesSerializer(
+    serializers.ModelSerializer
+):
+    class Meta:
+        model = models.ChangeRequestTemplateHeader
+        fields = '__all__'
\ No newline at end of file