Merge branch 'product-staging' into 'product-demo'

Product staging

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

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.AssetGroup
+        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 AssetGroup
+from app.entities.models import AMSAssetGroup
 
 
 class AssetGroupFilter(filters.FilterSet):
 
     class Meta:
-        model = AssetGroup
-        fields = '__all__'
\ No newline at end of file
+        model = AMSAssetGroup
+        fields = '__all__'

app/applicationlayer/ams/asset_group/views.py

@@ -11,24 +11,31 @@ 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.AssetGroup.objects.all()
+    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', 'asset_group'
+        '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 = self.get_serializer(data=form)
         serializer.is_valid(raise_exception=True)
         self.perform_create(serializer)
 
@@ -41,8 +48,39 @@ class AssetGroupViewset(viewsets.ModelViewSet):
             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)
@@ -75,6 +113,91 @@ 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)
+
+    @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/report/serializers.py

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

app/applicationlayer/ams/report/table_filters.py

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

app/applicationlayer/ams/report/views.py

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

app/applicationlayer/ams/report_type/serializers.py

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

app/applicationlayer/ams/report_type/table_filters.py

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

app/applicationlayer/ams/report_type/views.py

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

app/applicationlayer/ams/urls_ams.py

@@ -6,11 +6,21 @@ from rest_framework.urlpatterns import format_suffix_patterns
 from app.applicationlayer.ams.asset_group import views as assetgroup
 from app.applicationlayer.ams.ams_privilege import views as amsprivilege
 from app.applicationlayer.ams.ams_user_type.views import AMSUserTypeViewSet
+from app.applicationlayer.ams.asset_type import views as assettype
+from app.applicationlayer.ams.asset.views import AMSAssetViewSet
+from app.applicationlayer.ams.asset_stock.views import AMSAssetStockViewSet
+from app.applicationlayer.ams.report_type.views import AMSReportTypeViewset
+from app.applicationlayer.ams.report.views import AMSReportViewset
 
 router = routers.DefaultRouter()
 
 router.register(r'asset-group', assetgroup.AssetGroupViewset)
+router.register(r'asset-type', assettype.AssetTypeViewset)
 router.register(r'ams-privilege', amsprivilege.AMSPrivilegeViewSet)
+router.register(r'asset', AMSAssetViewSet)
+router.register(r'asset-stock', AMSAssetStockViewSet)
+router.register(r'report-type', AMSReportTypeViewset)
+router.register(r'report', AMSReportViewset)
 
 urlpatterns = [
     path('', include(router.urls)),

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'],
@@ -752,6 +752,8 @@ class ChangeRequestFormsViewset(viewsets.ModelViewSet):
 
         form_code = kwargs['form_code']
         form_data = request.data
+        
+        old_template_code = instance.template_no.template_no
 
         # generate batchno history
         batchno = get_max_batchno("batch")
@@ -795,17 +797,32 @@ class ChangeRequestFormsViewset(viewsets.ModelViewSet):
             new_instance
         )
 
-        change_request.form_add_edit_delete(
-                form_data['frm_approvers'],
-                models.ChangeRequestFormApprovers,
-                enums.CREntitiesEnum.CR_FRM_APPROVER.value,
-                ChangeRequestFormApproversSerializer,
-                partial,
-                self,
-                form_code,
-                batchno,
-                enums.CREnum.SAVE.value
-        )
+        new_template_code = serializer.validated_data['template_no'].template_no
+
+        if old_template_code == new_template_code:
+            change_request.form_add_edit_delete(
+                    form_data['frm_approvers'],
+                    models.ChangeRequestFormApprovers,
+                    enums.CREntitiesEnum.CR_FRM_APPROVER.value,
+                    ChangeRequestFormApproversSerializer,
+                    partial,
+                    self,
+                    form_code,
+                    batchno,
+                    enums.CREnum.SAVE.value
+            )
+        else:
+            change_request.form_add_edit_delete_for_draft(
+                    form_data['frm_approvers'],
+                    models.ChangeRequestFormApprovers,
+                    enums.CREntitiesEnum.CR_FRM_APPROVER.value,
+                    ChangeRequestFormApproversSerializer,
+                    partial,
+                    self,
+                    form_code,
+                    batchno,
+                    enums.CREnum.SAVE.value
+            )
         
         change_request.form_add_edit_delete(
                 form_data['frm_stakes'],

app/applicationlayer/management/account/views.py

@@ -17,7 +17,8 @@ from app.applicationlayer.utils import model_to_dict
 from app.entities.models import (
     User, EntityLog, PasswordReset, Application, UserImage,
     ChangeRequestFormHeader, ChangeRequestTemplateHeader,
-    AllowedCompany, Company, Department, UserHistory
+    AllowedCompany, Company, Department, UserHistory,
+    AMSPrivilege
 )
 
 from django.contrib.auth.hashers import make_password
@@ -32,6 +33,12 @@ from app.applicationlayer.utils import (
     CustomPagination, status_message_response, log_save,
     main_threading
 )
+import os
+import configparser
+
+config = configparser.ConfigParser()
+config_file = os.path.join('./', 'env.ini')
+config.read(config_file)
 
 
 class UserViewSet(viewsets.ModelViewSet):
@@ -181,7 +188,6 @@ class UserViewSet(viewsets.ModelViewSet):
         partial = kwargs.pop('partial', False)
         instance = self.get_object()
 
-
         cms_form = ChangeRequestFormHeader.objects.filter(
             Q(frm_approvers__user__code=instance.code) |
             Q(frm_stakes__user__code=instance.code) |
@@ -191,10 +197,10 @@ class UserViewSet(viewsets.ModelViewSet):
 
         cms_template = ChangeRequestTemplateHeader.objects.filter(
             Q(created_by_user__code=instance.code) |
-            Q(requested_to_user__code=instance.code) 
+            Q(requested_to_user__code=instance.code)
         )
         if instance.department.code != request.data['department']:
-
+            
             if cms_form.count() > 0 or cms_template.count() > 0:
 
                 error = 'Cannot update this record the user has a record on change request it might cause a data error'
@@ -220,16 +226,25 @@ class UserViewSet(viewsets.ModelViewSet):
             rms = Application.objects.filter(id=1).values('code').first()
             app.append(rms['code'])
 
-        app = Application.objects.filter(
+        app_data = Application.objects.filter(
             code__in=app
         )
 
+        if not config['APPLICATION_CODE']['AMS'] in app:
+            ams_priv = AMSPrivilege.objects.filter(
+                id_number=instance.code
+            ).delete()
+        
+        if not config['APPLICATION_CODE']['CMS'] in app:
+            cms_priv = AllowedCompany.objects.filter(
+                id_number=instance.code
+            ).delete()
+        
         instance = User.objects.get(
             id=serializer.data['id']
         )
 
-
-        instance.application.set(app)
+        instance.application.set(app_data)
         new_instance = serializer.data
 
         log_save(

app/businesslayer/changerequest/change_request.py

@@ -368,6 +368,55 @@ def form_add_edit_delete(form_request_body,
     return True
 
 
+def form_add_edit_delete_for_draft(form_request_body,
+                                    queryset,
+                                    entity,
+                                    serializer_data,
+                                    partial,
+                                    self,
+                                    form_code,
+                                    batch_no,
+                                    main_action):
+
+    delete_query = queryset.objects.filter(
+        form_code=form_code
+    )
+
+    if delete_query.count() > 0:
+        crhistory_log_bulk_delete(delete_query,
+                                  entity,
+                                  queryset,
+                                  form_code,
+                                  batch_no,
+                                  main_action
+        )
+    
+    for i in form_request_body:
+        
+        frm_code = {
+            "form_code": form_code
+        }
+        data = {**i, **frm_code}
+        serializer = serializer_data(data=data,
+                                     context={"request": self.request})
+        serializer.is_valid(raise_exception=True)
+
+        self.perform_create(serializer)
+        new_instance = serializer.data
+        
+        crhistory_save(
+            batch_no,
+            main_action,
+            enums.CREnum.ADD.value,
+            entity,
+            form_code,
+            None,
+            new_instance
+        )
+
+    return True
+
+
 def attachment_add_edit_delete(form_request_body,
                                queryset,
                                entity,

app/entities/enums.py

@@ -31,13 +31,17 @@ class GenerateCode(Enum):
     FORM_DETAIL = 'FRMDETAIL'
     ETL = 'ETL'
 
-    # ASSET_GROUP = 'AMSGRP'
     CMS_SETTINGS = "CMSSET"
 
     ASSET_TYPE = 'ASSTTYPE'
     ASSET = 'ASST'
     ASSET_STOCK = 'ASSTSTOCK'
     ASSET_GROUP = 'ASSTGRP'
+    ASSET_STOCK_SUPPORT = 'ASSTSTOCKSUP'
+    REPORT_TYPE = 'RPTTYPE'
+    REPORT = 'RPT'
+
+    FORM_ASSET = 'FRMASSET'
     
 '''
 *********
@@ -72,6 +76,15 @@ class LogEntitiesEnum(Enum):
     ChangeRequestFormDetails = "ChangeRequestFormDetails"
     ChangeRequestSettings = 'ChangeRequestSettings'
 
+    AMSReportType = 'AMSReportType'
+    AMSReport = 'AMSReport'
+    AMSAsset = 'AMSAsset'
+    AMSAssetStock = 'AMSAssetStock'
+    AMSAssetStockSupport = 'AMSAssetStockSupport'
+    AMSAssetType = 'AMSAssetType'
+    AMSAssetGroup = 'AMSAssetGroup'
+    
+
 '''
 *********
 CR HISTORY ENUMS

app/entities/migrations/0007_auto_20200318_1535.py

+# Generated by Django 2.2 on 2020-03-18 15:35
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('entities', '0006_auto_20200318_1314'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='entitylog',
+            name='entity',
+            field=models.CharField(choices=[('USER', 'USER'), ('APPLICATION', 'APPLICATION'), ('COMPANY', 'COMPANY'), ('DEPARTMENT', 'DEPARTMENT'), ('MODULE', 'MODULE'), ('DELEGATION', 'DELEGATION'), ('ChangeRequestTemplateHeader', 'ChangeRequestTemplateHeader'), ('ChangeRequestTemplateApprovers', 'ChangeRequestTemplateApprovers'), ('ChangeRequestTemplateStakeHolders', 'ChangeRequestTemplateStakeHolders'), ('ChangeRequestTemplateAttachments', 'ChangeRequestTemplateAttachments'), ('ChangeRequestTemplateDetails', 'ChangeRequestTemplateDetails'), ('ChangeRequestFormHeader', 'ChangeRequestFormHeader'), ('ChangeRequestFormApprovers', 'ChangeRequestFormApprovers'), ('ChangeRequestFormStakeHolders', 'ChangeRequestFormStakeHolders'), ('ChangeRequestFormAttachments', 'ChangeRequestFormAttachments'), ('ChangeRequestFormDetails', 'ChangeRequestFormDetails'), ('ChangeRequestSettings', 'ChangeRequestSettings'), ('AMSReportType', 'AMSReportType'), ('AMSReport', 'AMSReport'), ('AMSASSET', 'AMSASSET')], default='Add', max_length=50),
+        ),
+    ]

app/entities/migrations/0008_auto_20200318_1545.py

+# Generated by Django 2.2 on 2020-03-18 15:45
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('entities', '0007_auto_20200318_1535'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='entitylog',
+            name='entity',
+            field=models.CharField(choices=[('USER', 'USER'), ('APPLICATION', 'APPLICATION'), ('COMPANY', 'COMPANY'), ('DEPARTMENT', 'DEPARTMENT'), ('MODULE', 'MODULE'), ('DELEGATION', 'DELEGATION'), ('ChangeRequestTemplateHeader', 'ChangeRequestTemplateHeader'), ('ChangeRequestTemplateApprovers', 'ChangeRequestTemplateApprovers'), ('ChangeRequestTemplateStakeHolders', 'ChangeRequestTemplateStakeHolders'), ('ChangeRequestTemplateAttachments', 'ChangeRequestTemplateAttachments'), ('ChangeRequestTemplateDetails', 'ChangeRequestTemplateDetails'), ('ChangeRequestFormHeader', 'ChangeRequestFormHeader'), ('ChangeRequestFormApprovers', 'ChangeRequestFormApprovers'), ('ChangeRequestFormStakeHolders', 'ChangeRequestFormStakeHolders'), ('ChangeRequestFormAttachments', 'ChangeRequestFormAttachments'), ('ChangeRequestFormDetails', 'ChangeRequestFormDetails'), ('ChangeRequestSettings', 'ChangeRequestSettings'), ('AMSReportType', 'AMSReportType'), ('AMSReport', 'AMSReport'), ('AMSAsset', 'AMSAsset'), ('AMSAssetStock', 'AMSAssetStock'), ('AMSAssetStockSupport', 'AMSAssetStockSupport')], default='Add', max_length=50),
+        ),
+    ]

app/entities/migrations/0009_auto_20200318_1724.py

+# Generated by Django 2.2 on 2020-03-18 17:24
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('entities', '0008_auto_20200318_1545'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='entitylog',
+            name='entity',
+            field=models.CharField(choices=[('USER', 'USER'), ('APPLICATION', 'APPLICATION'), ('COMPANY', 'COMPANY'), ('DEPARTMENT', 'DEPARTMENT'), ('MODULE', 'MODULE'), ('DELEGATION', 'DELEGATION'), ('ChangeRequestTemplateHeader', 'ChangeRequestTemplateHeader'), ('ChangeRequestTemplateApprovers', 'ChangeRequestTemplateApprovers'), ('ChangeRequestTemplateStakeHolders', 'ChangeRequestTemplateStakeHolders'), ('ChangeRequestTemplateAttachments', 'ChangeRequestTemplateAttachments'), ('ChangeRequestTemplateDetails', 'ChangeRequestTemplateDetails'), ('ChangeRequestFormHeader', 'ChangeRequestFormHeader'), ('ChangeRequestFormApprovers', 'ChangeRequestFormApprovers'), ('ChangeRequestFormStakeHolders', 'ChangeRequestFormStakeHolders'), ('ChangeRequestFormAttachments', 'ChangeRequestFormAttachments'), ('ChangeRequestFormDetails', 'ChangeRequestFormDetails'), ('ChangeRequestSettings', 'ChangeRequestSettings'), ('AMSReportType', 'AMSReportType'), ('AMSReport', 'AMSReport'), ('AMSAsset', 'AMSAsset'), ('AMSAssetStock', 'AMSAssetStock'), ('AMSAssetStockSupport', 'AMSAssetStockSupport'), ('AMSAssetType', 'AMSAssetType'), ('AMSAssetGroup', 'AMSAssetGroup')], default='Add', max_length=50),
+        ),
+    ]

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

env.new_template.ini

@@ -22,7 +22,6 @@ cluster = api
 cms_notification = cms_notification
 
 
-
 [NOTIFICATION_EMAIL]
 APPROVER_MESSAGE = has sent you an APPROVAL REQUEST for change request;RMS-ACTIONREQUIRED
 REQUESTOR_MESSAGE = has APPROVED the change request;RMS-CRAPPROVED
@@ -35,3 +34,9 @@ VENDOR_REJECT_MESSAGE = has REJECTED the change request;RMS-CRREJECTED-VENDOR
 REVISED_MESSAGE = has REJECTED the change request for your revision;RMS-CRREVISED
 CANCEL_MESSAGE = has CANCELLED the change request;RMS-CRCANCELLED-USERTRIGGER
 APPROVER_REJECT_MESSAGE = has REJECTED the change request for your approval;RMS-CRREJECTED-APPROVER
+
+
+[APPLICATION_CODE]
+RMS = APP-20190923-0000001
+CMS = APP-20190923-0000002
+AMS = APP-20190923-0000003
\ No newline at end of file

media/uploads/user_format.csv

-Username,Name,Company,Department,Department_Code,Email,Contact_No,Application,Default_app,Privilege_Company,Privilege_Department,Privilege_Department_Code,Create_CR,Create_Template,View_All_CR,Approve_CR
-ob-john,John Doe,Oneberry Technologies Pte Ltd,Business Development,DEPARTMENT-20200122-0000003,johndoe@gmail.com,123456,"cms,ams",cms,Oneberry Technologies Pte Ltd,Business Development,DEPARTMENT-20200122-0000003,Yes,No,Yes,Yes
-,,,,,,,,,Please use this department code as reference,,,,,,
-,,,,,,,,,Oneberry Technologies Pte Ltd,Business Development,DEPARTMENT-20200122-0000003,,,,
-,,,,,,,,,JTC Corporation,Security,DEPARTMENT-20200122-0000002,,,,
-,,,,,,,,,Sample Company,Facilities Management,DEPARTMENT-20200130-0000004,,,,
+Username,Name,Company,Department,Department_Code,Email,Contact_No,Application,Default_app,Change_Request_Privilege_Company,Change_Request_Privilege_Department,Change_Request_Privilege_Department_Code,Create_CR,Create_Template,View_All_CR,View_All_CR_Template,Approve_CR,Asset_Management_Privilege_Company,Asset_Management_Privilege_Department,Asset_Management_Privilege_Department_Code,Asset_Management_User_Group
+ob-john,John Doe,Oneberry Technologies Pte Ltd,Business Development,DEPARTMENT-20200122-0000003,johndoe@gmail.com,123456,"cms,ams",cms,Oneberry Technologies Pte Ltd,Business Development,DEPARTMENT-20200122-0000003,Yes,No,Yes,Yes,Yes,Oneberry Technologies Pte Ltd,Business Development,DEPARTMENT-20200122-0000003,MANAGER
+,,,,,,,,,Please use this department code as reference,,,,,,,,,,,
+,,,,,,,,,Oneberry Technologies Pte Ltd,Business Development,DEPARTMENT-20200122-0000003,,,,,,,,,
+,,,,,,,,,JTC Corporation,Security,DEPARTMENT-20200122-0000002,,,,,,,,,
+,,,,,,,,,Sample Company,Facilities Management,DEPARTMENT-20200130-0000004,,,,,,,,,