Merge branch 'product-dev' into 'product-sit'

Product dev

See merge request rms/Backend/api-main-service!1020

app/applicationlayer/ams/asset/serializers.py

@@ -9,7 +9,9 @@ class AMSAssetSerializer(serializers.ModelSerializer):
         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='Faulty').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
 

app/applicationlayer/ams/asset/views.py

-from app.entities.models import AMSAsset
+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(
@@ -13,6 +14,9 @@ from app.applicationlayer.utils import(
 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):
@@ -33,7 +37,7 @@ class AMSAssetViewSet(viewsets.ModelViewSet):
 
     def list(self, request, *args, **kwargs):
 
-        queryset = self.filter_queryset(self.get_queryset())
+        queryset = self.filter_queryset(self.get_queryset()).filter(is_active=True)
 
         page = self.paginate_queryset(queryset)
 
@@ -57,9 +61,12 @@ class AMSAssetViewSet(viewsets.ModelViewSet):
         )
 
 
+    @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)
@@ -73,6 +80,8 @@ class AMSAssetViewSet(viewsets.ModelViewSet):
             message
         )
 
+    @AssetValidation
+    @transaction.atomic
     def update(self, request, *args, **kwargs):
         try:
             
@@ -89,7 +98,7 @@ class AMSAssetViewSet(viewsets.ModelViewSet):
 
             log_save(
                 enums.LogEnum.UPDATE.value,
-                enums.LogEntitiesEnum.AMSReport.value,
+                enums.LogEntitiesEnum.AMSAsset.value,
                 old_instance['id'],
                 old_instance,
                 new_instance
@@ -111,11 +120,91 @@ class AMSAssetViewSet(viewsets.ModelViewSet):
     def destroy(self, request, *args, **kwargs):
 
         instance = self.get_object()
-        self.perform_destroy(instance)
+        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)
 
-    #comment
+    @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'

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 AssetGroupSerializer(serializers.ModelSerializer):
+class AssetGroupSerializerList(serializers.ModelSerializer):
 
     def to_representation(self, instance):
         ret = super().to_representation(instance)
 
-        asset_stocks = models.AMSAssetStock.objects.filter(asset_group=instance.code)
-        
-        asset_counter = 0
-        asset_type_counter = 0
-        for asset_stock in asset_stocks:
-            asset_counter = asset_counter + models.AMSAsset.objects.filter(code=asset_stock.asset.code).count()
-            asset_type_counter = asset_type_counter + 1
+        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['asset_type_count'] = asset_type_counter
-        ret['asset_count'] = asset_counter
+        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', 'created_by', 'code']
\ No newline at end of file
+        read_only_fields = ['created', 'code']
\ No newline at end of file

app/applicationlayer/ams/asset_group/table_filters.py

@@ -6,4 +6,4 @@ class AssetGroupFilter(filters.FilterSet):
 
     class Meta:
         model = AMSAssetGroup
-        fields = '__all__'
\ No newline at end of file
+        fields = '__all__'

app/applicationlayer/ams/asset_group/views.py

@@ -12,10 +12,13 @@ from app.applicationlayer.utils import (
 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
@@ -26,28 +29,58 @@ class AssetGroupViewset(viewsets.ModelViewSet):
         '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=request.data)
-        # serializer.is_valid(raise_exception=True)
+        serializer = self.get_serializer(data=form)
+        serializer.is_valid(raise_exception=True)
+        self.perform_create(serializer)
 
-        if serializer.is_valid(raise_exception=True):
-            serializer.save(created_by=self.request.user)
+        message = status_message_response(
+            201, 'success',
+            'New Asset Group created', serializer.data
+        )
 
-            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
+                {"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)
@@ -80,7 +113,26 @@ class AssetGroupViewset(viewsets.ModelViewSet):
     def destroy(self, request, *args, **kwargs):
 
         instance = self.get_object()
-        self.perform_destroy(instance)
+        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)
 
@@ -113,3 +165,39 @@ class AssetGroupViewset(viewsets.ModelViewSet):
             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/views.py

@@ -11,6 +11,12 @@ 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):
@@ -33,7 +39,7 @@ class AMSAssetStockViewSet(viewsets.ModelViewSet):
 
     def list(self, request, *args, **kwargs):
 
-        queryset = self.filter_queryset(self.get_queryset())
+        queryset = self.filter_queryset(self.get_queryset()).filter(is_active=True)
 
         page = self.paginate_queryset(queryset)
 
@@ -55,8 +61,102 @@ class AMSAssetStockViewSet(viewsets.ModelViewSet):
             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):
 
@@ -83,7 +183,17 @@ class AMSAssetStockViewSet(viewsets.ModelViewSet):
     def destroy(self, request, *args, **kwargs):
 
         instance = self.get_object()
-        self.perform_destroy(instance)
+        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)
 
@@ -116,3 +226,39 @@ class AMSAssetStockViewSet(viewsets.ModelViewSet):
             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

@@ -22,4 +22,4 @@ class AssetTypeSerializer(serializers.ModelSerializer):
     class Meta:
         model = models.AMSAssetType
         fields = '__all__'
-        read_only_fields = ['created', 'created_by', 'code']
\ No newline at end of file
+        read_only_fields = ['created', 'code']
\ No newline at end of file

app/applicationlayer/ams/asset_type/views.py

@@ -13,8 +13,10 @@ 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
-from app.entities import enums
+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):
@@ -29,47 +31,61 @@ class AssetTypeViewset(viewsets.ModelViewSet):
         'code', 'name'
     )
 
+    @AssetTypeValidation
     @transaction.atomic
     def create(self, request, *args, **kwargs):
-
-        serializer = self.get_serializer(data=request.data)
-        # serializer.is_valid(raise_exception=True)
+        form = request.data
+        form['created_by'] = request.user.code
         
-        # if requestor == poc:
-        #     message = {
-        #         'code': 400,
-        #         'status': 'failed',
-        #         'message': 'Cannot assign same user on point of contact and requestor',
-        #     }
-        #     return Response(message, status=status.HTTP_400_BAD_REQUEST)
-
-        if serializer.is_valid(raise_exception=True):
-            serializer.save(created_by=self.request.user)
-            self.perform_create(serializer)
+        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
+        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
+                {"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())
-        # queryset = models.AMSAssetType.objects.annotate(
-        #             view_count=Sum(
-        #                 When(relations_item__has_viewed=True, then=1),
-        #                 output_field=IntegerField(),
-        #             ),
-        #             love_count=Sum(
-        #                 When(relations_item__has_loved=True, then=1),
-        #                 output_field=IntegerField(),
-        #             ),
-        #         )
- 
+
         page = self.paginate_queryset(queryset)
 
         if page is not None:
@@ -100,17 +116,26 @@ class AssetTypeViewset(viewsets.ModelViewSet):
     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.,
-        #     new_instance['id'],
-        #     new_instance,
-        #     ''
-        # )
+        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)
 
@@ -144,15 +169,26 @@ class AssetTypeViewset(viewsets.ModelViewSet):
             status=status.HTTP_200_OK
         )
     
-    #restore archived asset_type
-    def partial_update(self, request, *args, **kwargs):
+    @action(
+        methods=['PATCH'], detail=True,
+        url_path='restore', url_name='restore'
+    )
+    def restore(self, request, code=None):
+
         try:
-            kwargs['partial'] = True
-            code = self.kwargs['code']
-            instance = models.AMSAssetType.objects.filter(
-                code=code
+            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,
+                ''
             )
-            instance.update(is_active=True)
+
             message = status_message_response(
                 200, 'success',
                 'Archived Asset Type restored',
@@ -160,7 +196,7 @@ class AssetTypeViewset(viewsets.ModelViewSet):
             )
 
             return Response(message, status=status.HTTP_200_OK)
-
+        
         except Exception as e:
             message = status_message_response(
                             500, 'failed',

app/applicationlayer/ams/report/views.py

@@ -167,17 +167,33 @@ class AMSReportViewset(viewsets.ModelViewSet):
         url_path='restore', url_name='restore'
     )
     def restore(self, request, code=None):
-        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,
-            ''
-        )
 
-        return Response(status=status.HTTP_204_NO_CONTENT)
+        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/views.py

@@ -160,23 +160,38 @@ class AMSReportTypeViewset(viewsets.ModelViewSet):
             status=status.HTTP_200_OK
         )
 
-
     @action(
         methods=['PATCH'], detail=True,
         url_path='restore', url_name='restore'
     )
     def restore(self, request, code=None):
-        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,
-            ''
-        )
+        try:
+            instance = self.get_object()
+            instance.is_active = True
+            instance.save()
+            new_instance = model_to_dict(instance)
 
-        return Response(status=status.HTTP_204_NO_CONTENT)
+            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

@@ -17,8 +17,8 @@ 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'assets', AMSAssetViewSet)
-router.register(r'assets-stock-list', AMSAssetStockViewSet)
+router.register(r'asset', AMSAssetViewSet)
+router.register(r'asset-stock', AMSAssetStockViewSet)
 router.register(r'report-type', AMSReportTypeViewset)
 router.register(r'report', AMSReportViewset)
 

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

@@ -111,7 +111,7 @@ class ChangeRequestFormsViewset(viewsets.ModelViewSet):
         "requested_to_user__name", "requested_to_template_name",
         "requested_to_objective", "requested_to_priority", "description"
     )
-# comment
+
     def list(self, request, *args, **kwargs):
         
         self.serializer_class = ChangeRequestFormHeaderSerializerList
@@ -236,7 +236,7 @@ class ChangeRequestFormsViewset(viewsets.ModelViewSet):
             'message': 'Dashboard Summary'
         }
 
-        return Response(message, status=status.HTTP_200_OK)        
+        return Response(message, status=status.HTTP_200_OK)      
 
     @action(detail=False,
             methods=['get'],

app/entities/models.py

@@ -1286,7 +1286,6 @@ class AMSAssetGroup(models.Model):
         related_name='ams_asset_group_created_by'
     )
     created = models.DateTimeField(auto_now_add=True)
-    # deleted_at = models.DateTimeField(null=True, blank=True)
     is_active = models.BooleanField(default=True)
     
     class Meta:
@@ -1325,7 +1324,6 @@ class AMSAssetType(models.Model):
         related_name='ams_asset_type_created_by'
     )
     created = models.DateTimeField(auto_now_add=True)
-    # deleted_at = models.DateTimeField(null=True, blank=True)
     is_active = models.BooleanField(default=True)
     
     class Meta:
@@ -1360,7 +1358,6 @@ class AMSAsset(models.Model):
         to_field='code',
         related_name='ams_asset_type'
     )
-    # asset_type = models.ManyToManyField(AMSAssetType)
     description = models.CharField(
         blank=True,
         null=True,
@@ -1372,7 +1369,6 @@ class AMSAsset(models.Model):
         related_name='ams_asset_created_by'
     )
     created = models.DateTimeField(auto_now_add=True)
-    # deleted_at = models.DateTimeField(null=True, blank=True)
     is_active = models.BooleanField(default=True)
     
     class Meta:
@@ -1443,7 +1439,6 @@ class AMSAssetStock(models.Model):
         related_name='ams_asset_to_assetgroup'
     )
     created = models.DateTimeField(auto_now_add=True)
-    # deleted_at = models.DateTimeField(null=True, blank=True)
     is_active = models.BooleanField(default=True)
     
     class Meta:
@@ -1489,7 +1484,6 @@ class AMSAssetStockSupport(models.Model):
         to_field='code'
     )
     created = models.DateTimeField(auto_now_add=True)
-    # deleted_at = models.DateTimeField(null=True, blank=True)
     is_active = models.BooleanField(default=True)
     
     class Meta:

app/helper/decorators.py

@@ -18,6 +18,7 @@ from app.businesslayer.changerequest.change_request_template import (
     validation_vendor_unique_level
 )
 from app.applicationlayer.utils import error_message
+from app.entities import models
 
 
 def error_safe(function):
@@ -414,3 +415,189 @@ def FormValidation(function):
         
         return function(self, request, *args, **kwargs)
     return wrapper
+
+
+def AssetValidation(function):
+    @wraps(function)
+    def wrapper(self, request, *args, **kwargs):
+        form = request.data
+        if 'name' not in form:
+            return error_message(
+                '400', "The key name is required",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+
+        if len(form['name']) == 0:
+            return error_message(
+                '400', "Asset name is required",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+
+        check_existing = models.AMSAsset.objects.filter(name=form['name']).count()
+        if check_existing >= 1:
+            return error_message(
+                '400', "Asset with this name already exists.",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+
+        if 'asset_type' not in form:
+            return error_message(
+                '400', "The key asset_type is required",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+
+        valid_asset_type = models.AMSAssetType.objects.filter(
+            Q(code=form['asset_type']) &
+            Q(is_active=True)
+        ).count()
+        if valid_asset_type <= 0:
+            return error_message(
+                '400', "Invalid Asset Type",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+
+        return function(self, request, *args, **kwargs)
+    return wrapper
+
+
+def AssetStockValidation(function):
+    @wraps(function)
+    def wrapper(self, request, *args, **kwargs):
+        form = request.data
+        fields = ["asset_type"]
+        fields.append("unique_identifier")
+        fields.append("status")
+        fields.append( "acquisition_type")
+        fields.append("location")
+        fields.append("user_client")
+        fields.append("manager")
+        fields.append("dynamic_field")
+        fields.append("asset_group")
+        fields.append("asset")
+        print(fields)
+
+        for data in fields:
+            if str(data) not in form:
+                return error_message(
+                    '400', f"The key {data.replace('_', ' ')}  is required",
+                    'failed', status.HTTP_400_BAD_REQUEST
+                )
+
+        for data in form.keys():
+            if str(data) != 'dynamic_field':
+                if len(data) == 0:
+                    return error_message(
+                        '400', f"{data.replace('_', ' ')} is required",
+                        'failed', status.HTTP_400_BAD_REQUEST
+                    )
+
+        unique_identifier = models.AMSAssetStock.objects.filter(
+            unique_identifier=form['unique_identifier']
+        ).count()
+
+        if unique_identifier >= 1:
+            return error_message(
+                '400', "unique identifier already exists.",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+
+        user_client = models.User.objects.filter(
+            code=form['user_client']
+        ).count()
+
+        if user_client <= 0:
+            return error_message(
+                '400', "User does not exists.",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+
+        manager = models.User.objects.filter(
+            code=form['manager']
+        ).count()
+
+        if manager <= 0:
+            return error_message(
+                '400', "User for manager does not exists.",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+
+        asset = models.AMSAsset.objects.filter(
+            code=form['asset']
+        ).count()
+        if asset <= 0:
+            return error_message(
+                '400', "Asset does not exists.",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+        
+        asset_group = models.AMSAssetGroup.objects.filter(
+            code=form['asset_group']
+        ).count()
+        if asset_group <= 0:
+            return error_message(
+                '400', "Asset Group does not exists.",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+
+        valid_asset_type = models.AMSAssetType.objects.filter(
+            Q(code=form['asset_type']) &
+            Q(is_active=True)
+        ).count()
+        if valid_asset_type <= 0:
+            return error_message(
+                '400', "Invalid Asset Type",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+
+        return function(self, request, *args, **kwargs)
+    return wrapper
+
+
+def AssetGroupValidation(function):
+    @wraps(function)
+    def wrapper(self, request, *args, **kwargs):
+        form = request.data
+        if 'name' not in form:
+            return error_message(
+                '400', "The key name is required",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+        if len(form['name']) == 0:
+            return error_message(
+                '400', "Asset Group name is required",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+        check_existing = models.AMSAssetGroup.objects.filter(name=form['name']).count()
+        if check_existing >= 1:
+            return error_message(
+                '400', "Asset Group with this name already exists.",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+
+        return function(self, request, *args, **kwargs)
+    return wrapper
+
+
+def AssetTypeValidation(function):
+    @wraps(function)
+    def wrapper(self, request, *args, **kwargs):
+        form = request.data
+        if 'name' not in form:
+            return error_message(
+                '400', "The key name is required",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+        if len(form['name']) == 0:
+            return error_message(
+                '400', "Asset Type name is required",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+        check_existing = models.AMSAssetType.objects.filter(name=form['name']).count()
+        if check_existing >= 1:
+            return error_message(
+                '400', "Asset Type with this name already exists.",
+                'failed', status.HTTP_400_BAD_REQUEST
+            )
+        
+        return function(self, request, *args, **kwargs)
+    return wrapper
\ No newline at end of file