initial commit

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/red-ci-cd/
+
+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
+EXPOSE 1000
+RUN python manage.py migrate

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/red-ci-cd/
+
+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)