Merge branch 'product-sit' into 'product-staging'

Product sit

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

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
+        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
@@ -753,6 +753,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,6 +797,9 @@ class ChangeRequestFormsViewset(viewsets.ModelViewSet):
             new_instance
         )
 
+        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,
@@ -806,6 +811,18 @@ class ChangeRequestFormsViewset(viewsets.ModelViewSet):
                     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) |
@@ -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/applicationlayer/management/batchupload/views.py

@@ -18,8 +18,8 @@ from app.applicationlayer.management.batchupload.serializer import (
     BatchUploadSerializer
 )
 from app.entities.models import (
-    User, Application, ExtractTransformLoad,
-    AllowedCompany, Company, Department, UserHistory, MasterAttachment
+    User, Application, ExtractTransformLoad, AllowedCompany,
+    Company, Department, UserHistory, MasterAttachment, AMSPrivilege
 )
 from app.applicationlayer.utils import (
     status_message_response,
@@ -40,6 +40,7 @@ from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
 from reportlab.lib.pagesizes import A4
 from reportlab.lib.enums import TA_JUSTIFY, TA_RIGHT, TA_LEFT, TA_CENTER
 from reportlab.lib.colors import red
+from django.db import transaction
 
 
 config = configparser.ConfigParser()
@@ -207,48 +208,73 @@ class BatchUploadViewSet(viewsets.ModelViewSet):
             attach_user.first().delete()
         
         departments = Department.objects.exclude(id=1).annotate(
-            Privilege_Company=F('company__name'),
-            Privilege_Department=F('name'),
-            Privilege_Department_Code=F('code')
+            Change_Request_Privilege_Company=F('company__name'),
+            Change_Request_Privilege_Department=F('name'),
+            Change_Request_Privilege_Department_Code=F('code')
         ).values(
-            'Privilege_Company',
-            'Privilege_Department',
-            'Privilege_Department_Code'
+            'Change_Request_Privilege_Company',
+            'Change_Request_Privilege_Department',
+            'Change_Request_Privilege_Department_Code'
+        )
+
+        ams_user_groups = []
+        for a in enums.AMSUserTypeEnum:
+            ams_user_groups.append(
+                {
+                    "Asset_Management_Privilege_Department": '',
+                    "Asset_Management_Privilege_Department_Code": '',
+                    "Asset_Management_User_Group": a.name
+                }
             )
         
         data = {
             'Username': ["ob-john"],
             'Name': ["John Doe"],
-            'Company': [departments[0]['Privilege_Company']],
-            'Department': [departments[0]['Privilege_Department']],
-            'Department_Code': [departments[0]['Privilege_Department_Code']],
+            'Company': [departments[0]['Change_Request_Privilege_Company']],
+            'Department': [departments[0]['Change_Request_Privilege_Department']],
+            'Department_Code': [departments[0]['Change_Request_Privilege_Department_Code']],
             'Email': ["johndoe@gmail.com"],
             'Contact_No': ["123456"],
             'Application': ["cms,ams"],
             'Default_app': ["cms"],
-            'Privilege_Company': [departments[0]['Privilege_Company']],
-            'Privilege_Department': [departments[0]['Privilege_Department']],
-            'Privilege_Department_Code': [departments[0]['Privilege_Department_Code']],
+            'Change_Request_Privilege_Company': [departments[0]['Change_Request_Privilege_Company']],
+            'Change_Request_Privilege_Department': [departments[0]['Change_Request_Privilege_Department']],
+            'Change_Request_Privilege_Department_Code': [departments[0]['Change_Request_Privilege_Department_Code']],
             'Create_CR': ["Yes"],
             'Create_Template': ["No"],
             'View_All_CR': ["Yes"],
-            'Approve_CR': ["Yes"]
+            'View_All_CR_Template': ["Yes"],
+            'Approve_CR': ["Yes"],
+            'Asset_Management_Privilege_Company': [departments[0]['Change_Request_Privilege_Company']],
+            'Asset_Management_Privilege_Department': [departments[0]['Change_Request_Privilege_Department']],
+            'Asset_Management_Privilege_Department_Code': [departments[0]['Change_Request_Privilege_Department_Code']],
+            'Asset_Management_User_Group': "MANAGER"
         }
 
         cols = ['Username', 'Name', 'Company', 'Department', 'Department_Code']
         cols += ['Email', 'Contact_No', 'Application', 'Default_app']
-        cols += ['Privilege_Company', 'Privilege_Department', 'Privilege_Department_Code']
-        cols += ['Create_CR', 'Create_Template', 'View_All_CR', 'Approve_CR']
+        cols += ['Change_Request_Privilege_Company', 'Change_Request_Privilege_Department', 'Change_Request_Privilege_Department_Code']
+        cols += ['Create_CR', 'Create_Template', 'View_All_CR','View_All_CR_Template', 'Approve_CR']
+        cols += ['Asset_Management_Privilege_Company', 'Asset_Management_Privilege_Department', 'Asset_Management_Privilege_Department_Code', 'Asset_Management_User_Group']
 
         df = pd.DataFrame(data)
 
-        header = {"Privilege_Company": ['Please use this department code as reference']}
+        header = {"Change_Request_Privilege_Company": ['Please use this department code as reference'],
+                  "Asset_Management_User_Group": ['Please use this user group as reference']}
+        
         df3 = pd.DataFrame(
             header
         )
-        df2 = pd.DataFrame(
+
+        df_dept = pd.DataFrame(
             departments
         )
+
+        df_ams = pd.DataFrame(
+            ams_user_groups
+        )
+        
+        df2 = df_dept.join(df_ams, how='right')
         df_row_reindex = pd.concat([df, df3, df2])
         df_row_reindex = df_row_reindex.reindex(columns=cols)
         df_row_reindex = df_row_reindex.to_csv(index=False, line_terminator='\n')
@@ -273,9 +299,11 @@ class BatchUploadViewSet(viewsets.ModelViewSet):
         
         return self.get_paginated_response(message)
 
+    @transaction.atomic
     def create(self, request, **kwargs):
         csv_file = request.FILES['file']
         extension_file = str(csv_file).split('.')[1]
+        sp1 = transaction.savepoint()
 
         if extension_file.lower() != 'csv':
             return Response(
@@ -293,6 +321,8 @@ class BatchUploadViewSet(viewsets.ModelViewSet):
 
         department_error = 'Department should be same with the logged user'
         company_error = 'Company should be same with the logged user'
+        application_cms_error  = 'Please indicate cms in the Application column'
+        application_ams_error  = 'Please indicate ams in the Application column'
 
         etl = ExtractTransformLoad.objects.create(
             file_name=str(csv_file),
@@ -321,7 +351,7 @@ class BatchUploadViewSet(viewsets.ModelViewSet):
                         Q(company=user_company)
                     )
                     if not request_department:
-                        etl2.delete()
+                        # etl2.delete()
                         return Response(
                             {"message": company_error},
                             status=status.HTTP_400_BAD_REQUEST
@@ -329,7 +359,7 @@ class BatchUploadViewSet(viewsets.ModelViewSet):
 
                 elif request.user.user_type == enums_department:
                     if keys['Department_Code'] != request.user.department.code:
-                        etl2.delete()
+                        # etl2.delete()
                         return Response(
                             {"message": department_error},
                             # {"message": str(e)},
@@ -341,13 +371,27 @@ class BatchUploadViewSet(viewsets.ModelViewSet):
                         name__icontains=keys['Department_Code']
                     )
                     
+                try:
                     default_app = Application.objects.filter(
                         excel_code=keys['Default_app']
                     ).first()
+                except Exception as e:
+                    transaction.savepoint_rollback(sp1)
+                    return Response(
+                        {"message": f"Invalid Default Application at row {data + 2}"},
+                        status=status.HTTP_400_BAD_REQUEST
+                    )
 
+                try:
                     dept_code = Department.objects.get(
                         code=keys['Department_Code']
                     )
+                except Exception as e:
+                    transaction.savepoint_rollback(sp1)
+                    return Response(
+                        {"message": f"Invalid Department Code at row {data + 2}"},
+                        status=status.HTTP_400_BAD_REQUEST
+                    )
                 
                 users = {
                     "username": keys['Username'],
@@ -376,6 +420,11 @@ class BatchUploadViewSet(viewsets.ModelViewSet):
                         excel_code__in=keys['Application'].split(',')
                     )
 
+                    app_excel_code = []
+
+                    for i in app:
+                        app_excel_code.append(i.excel_code)
+
                     current_user.application.set(app)
                     current_user = User.objects.get(id=current_user.id)
 
@@ -398,15 +447,19 @@ class BatchUploadViewSet(viewsets.ModelViewSet):
                 else:
                     current_user = check_user[0]
                 
+                # cms privilege
                 try:
-                    privilege_department_code = keys['Privilege_Department_Code']
+                    privilege_department_code = keys['Change_Request_Privilege_Department_Code']
                     privilege_department_code = Department.objects.get(
                         code=privilege_department_code
                     )
+                    # if privilege_department_code:
                         
+                    #     if 'cms' in app_excel_code:
                     ccr = True if str(keys['Create_CR']).lower() == 'yes' else False
                     crt = True if str(keys['Create_Template']).lower() == 'yes' else False
                     view_all = True if str(keys['View_All_CR']).lower() == 'yes' else False
+                    view_all_template = True if str(keys['View_All_CR_Template']).lower() == 'yes' else False
                     approve_cr = True if str(keys['Approve_CR']).lower() == 'yes' else False
 
                     privilege_object = {
@@ -416,41 +469,103 @@ class BatchUploadViewSet(viewsets.ModelViewSet):
                         "create_change_request": ccr,
                         "create_change_request_template": crt,
                         "view_all_change_request": view_all,
+                        "view_all_change_request_template": view_all_template,
                         "approve_cr": approve_cr
                     }
-
                     AllowedCompany.objects.create(**privilege_object)
+                # else:
+                #     return Response(
+                #         {"message": f"Please indicate cms application at row {data + 2}"},
+                #         status=status.HTTP_400_BAD_REQUEST
+                #     )
 
                 except IntegrityError as e:
-                    etl2.delete()
+                    # etl2.delete()
+                    # transaction.savepoint_rollback(sp1)
                     return Response(
                         {"message": f"Duplicate user privilege at row {data + 2}"},
                         status=status.HTTP_400_BAD_REQUEST
                     )
 
                 except ObjectDoesNotExist as e:
-                    etl2.delete()
+                    # etl2.delete()
+                    transaction.savepoint_rollback(sp1)
                     return Response(
                         {"message": f"Department Does not Exist at Privilege row {data + 2}"},
                         status=status.HTTP_400_BAD_REQUEST
                     )
 
+                # ams privilege
+                try:
+                    # ams_privilege_department_code = keys['Asset_Management_Privilege_Department_Code']
+                    # if('ams' in app_excel_code and
+                    #         ams_privilege_department_code is None):
+                    #             print("none")
+                    # elif:
+                    #     return Response(
+                    #         {"message": f"Please indicate ams application at row {data + 2}"},
+                    #         status=status.HTTP_400_BAD_REQUEST
+                    #     )
+
+                    ams_privilege_department_code = keys['Asset_Management_Privilege_Department_Code']
+                    ams_privilege_department_code = Department.objects.get(
+                        code=ams_privilege_department_code
+                    )
+
+                    # if ams_privilege_department_code:
+                        
+                    ams_privilege_department_code = keys[
+                        'Asset_Management_Privilege_Department_Code']
+                    ams_privilege_department_code = Department.objects.get(
+                        code=ams_privilege_department_code
+                    )
+                    asset_user_code = keys['Asset_Management_User_Group']
+
+                    privilege_object_ams = {
+                        "id_number": current_user,
+                        "department": ams_privilege_department_code,
+                        "ams_user_type": asset_user_code
+                    }
+                    
+                    AMSPrivilege.objects.create(**privilege_object_ams)
+                    
+                except IntegrityError as e:
+                    # etl2.delete()
+                    # transaction.savepoint_rollback(sp1)
+                    return Response(
+                        {"message": f"Duplicate ams privilege at row {data + 2}"},
+                        status=status.HTTP_400_BAD_REQUEST
+                    )
+
+                except ObjectDoesNotExist as e:
+                    # etl2.delete()
+                    transaction.savepoint_rollback(sp1)
+                    return Response(
+                        {"message": f"Department Does not Exist at AMS Privilege row {data + 2}"},
+                        status=status.HTTP_400_BAD_REQUEST
+                    )
+                
+                # end of ams privilege
+
             except IntegrityError as e:
-                etl2.delete()
+                # etl2.delete()
+                # transaction.savepoint_rollback(sp1)
                 return Response(
                     {"message": f"Record already exist at row {data + 2}"},
                     status=status.HTTP_400_BAD_REQUEST
                 )
 
             except KeyError as e:
-                etl2.delete()
+                # etl2.delete()
+                transaction.savepoint_rollback(sp1)
                 return Response(
                     {"message": f"Missing column {e.args[0]}"},
                     status=status.HTTP_400_BAD_REQUEST
                 )
             
             except ObjectDoesNotExist as e:
-                etl2.delete()
+                # etl2.delete()
+                transaction.savepoint_rollback(sp1)
                 return Response(
                     {"message": f"Department Does not Exist at row {data + 2}"},
                     status=status.HTTP_400_BAD_REQUEST

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/0006_auto_20200318_1314.py

+# Generated by Django 2.2 on 2020-03-18 13:14
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('entities', '0005_amsprivilege'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='AMSAsset',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('code', models.CharField(default='', max_length=255, unique=True)),
+                ('name', models.CharField(max_length=255, unique=True)),
+                ('description', models.CharField(blank=True, max_length=255, null=True)),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('is_active', models.BooleanField(default=True)),
+            ],
+            options={
+                'db_table': 'ams_assets',
+                'ordering': ['-created'],
+            },
+        ),
+        migrations.CreateModel(
+            name='AMSAssetGroup',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('code', models.CharField(max_length=255, unique=True)),
+                ('name', models.CharField(max_length=255, unique=True)),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('is_active', models.BooleanField(default=True)),
+                ('created_by', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='ams_asset_group_created_by', to=settings.AUTH_USER_MODEL, to_field='code')),
+            ],
+            options={
+                'db_table': 'ams_asset_groups',
+                'ordering': ['-created'],
+            },
+        ),
+        migrations.CreateModel(
+            name='AMSAssetStock',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('code', models.CharField(default='', max_length=255, unique=True)),
+                ('unique_identifier', models.CharField(max_length=255, unique=True)),
+                ('status', models.CharField(choices=[('In-Store', 'In-Store'), ('Deployed', 'Deployed'), ('Returned', 'Returned'), ('Written Off', 'Written Off'), ('Faulty', 'Faulty')], default='In-Store', max_length=100)),
+                ('acquisition_type', models.CharField(choices=[('Owned', 'Owned'), ('Loan', 'Loan')], default='Owned', max_length=100)),
+                ('location', models.CharField(max_length=255)),
+                ('dynamic_field', models.TextField(blank=True, null=True)),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('is_active', models.BooleanField(default=True)),
+                ('asset', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='ams_asset_to_assetdetail', to='entities.AMSAsset', to_field='code')),
+                ('asset_group', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='ams_asset_to_assetgroup', to='entities.AMSAssetGroup', to_field='code')),
+                ('manager', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='ams_asset_manager', to=settings.AUTH_USER_MODEL, to_field='code')),
+                ('user_client', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='ams_asset_user_client', to=settings.AUTH_USER_MODEL, to_field='code')),
+            ],
+            options={
+                'db_table': 'ams_asset_stocks',
+                'ordering': ['-created'],
+            },
+        ),
+        migrations.CreateModel(
+            name='AMSAssetStockSupport',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('code', models.CharField(max_length=255, unique=True)),
+                ('name', models.CharField(max_length=255, unique=True)),
+                ('start_date', models.DateTimeField(blank=True, null=True)),
+                ('end_date', models.DateTimeField(blank=True, null=True)),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('is_active', models.BooleanField(default=True)),
+                ('asset_stock', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='entities.AMSAssetStock', to_field='code')),
+                ('created_by', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='ams_asset_stock_created_by', to=settings.AUTH_USER_MODEL, to_field='code')),
+            ],
+            options={
+                'db_table': 'ams_asset_stock_supports',
+                'ordering': ['-created'],
+            },
+        ),
+        migrations.CreateModel(
+            name='AMSAssetType',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('code', models.CharField(max_length=255, unique=True)),
+                ('name', models.CharField(max_length=255, unique=True)),
+                ('dynamic_field', models.TextField(blank=True, null=True)),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('is_active', models.BooleanField(default=True)),
+                ('created_by', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='ams_asset_type_created_by', to=settings.AUTH_USER_MODEL, to_field='code')),
+            ],
+            options={
+                'db_table': 'ams_asset_types',
+                'ordering': ['-created'],
+            },
+        ),
+        migrations.CreateModel(
+            name='AMSAuditTrail',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('code', models.CharField(max_length=255, unique=True)),
+                ('name', models.CharField(max_length=255, unique=True)),
+                ('description', models.CharField(blank=True, max_length=255, null=True)),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('deleted_at', models.DateTimeField(blank=True, null=True)),
+                ('asset_stock', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='entities.AMSAssetStock', to_field='code')),
+                ('created_by', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='ams_audit_trail_created_by', to=settings.AUTH_USER_MODEL, to_field='code')),
+            ],
+            options={
+                'db_table': 'ams_audit_trail',
+                'ordering': ['-created'],
+            },
+        ),
+        migrations.CreateModel(
+            name='AMSReport',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('code', models.CharField(default='', max_length=255, unique=True)),
+                ('name', models.CharField(max_length=255, unique=True)),
+                ('dynamic_field', models.TextField(blank=True, null=True)),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('is_active', models.BooleanField(default=True)),
+                ('asset_stock', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='report_to_asset_stock', to='entities.AMSAssetStock', to_field='code')),
+                ('created_by', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='ams_report_created_by', to=settings.AUTH_USER_MODEL, to_field='code')),
+            ],
+            options={
+                'db_table': 'ams_reports',
+                'ordering': ['-created'],
+            },
+        ),
+        migrations.CreateModel(
+            name='AMSReportType',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('code', models.CharField(default='', max_length=255, unique=True)),
+                ('name', models.CharField(max_length=255, unique=True)),
+                ('description', models.CharField(blank=True, max_length=255, null=True)),
+                ('dynamic_field', models.TextField(blank=True, null=True)),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('is_active', models.BooleanField(default=True)),
+                ('created_by', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='ams_report_type_created_by', to=settings.AUTH_USER_MODEL, to_field='code')),
+            ],
+            options={
+                'db_table': 'ams_report_types',
+                'ordering': ['-created'],
+            },
+        ),
+        migrations.CreateModel(
+            name='ChangeRequestFormAssets',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('code', models.CharField(max_length=255, unique=True)),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('deleted_at', models.DateTimeField(blank=True, null=True)),
+                ('asset_stock', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='entities.AMSAssetStock', to_field='code')),
+                ('created_by', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='cms_form_assets_created_by', to=settings.AUTH_USER_MODEL, to_field='code')),
+                ('form_code', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='change_request_form_assets', to='entities.ChangeRequestFormHeader', to_field='form_code')),
+            ],
+            options={
+                'db_table': 'change_request_form_assets',
+                'ordering': ['-created'],
+            },
+        ),
+        migrations.DeleteModel(
+            name='AssetGroup',
+        ),
+        migrations.AlterField(
+            model_name='amsprivilege',
+            name='ams_user_type',
+            field=models.CharField(choices=[('MANAGER', 'MANAGER'), ('USER_CLIENT', 'USER_CLIENT'), ('SUPPORT', 'SUPPORT'), ('VIEWER', 'VIEWER')], default='MANAGER', max_length=100),
+        ),
+        migrations.AlterField(
+            model_name='amsprivilege',
+            name='department',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='ams_privilege_departments', to='entities.Department', to_field='code'),
+        ),
+        migrations.AlterField(
+            model_name='amsprivilege',
+            name='id_number',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='ams_privilege_id_number', to=settings.AUTH_USER_MODEL, to_field='code'),
+        ),
+        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')], default='Add', max_length=50),
+        ),
+        migrations.AlterField(
+            model_name='extracttransformload',
+            name='model_type',
+            field=models.CharField(choices=[('APP', 'APP'), ('MODULE', 'MODULE'), ('COMPANY', 'COMPANY'), ('DEPARTMENT', 'DEPARTMENT'), ('USER', 'USER'), ('DELEGATION', 'DELEGATION'), ('NOTIF', 'NOTIF'), ('TMP', 'TMP'), ('TMPAPR', 'TMPAPR'), ('TMPSTK', 'TMPSTK'), ('TMPATCH', 'TMPATCH'), ('TMPDETAIL', 'TMPDETAIL'), ('FRM', 'FRM'), ('FRMAPR', 'FRMAPR'), ('FRMSTK', 'FRMSTK'), ('FRMATCH', 'FRMATCH'), ('FRMDETAIL', 'FRMDETAIL'), ('ETL', 'ETL'), ('CMSSET', 'CMSSET'), ('ASSTTYPE', 'ASSTTYPE'), ('ASST', 'ASST'), ('ASSTSTOCK', 'ASSTSTOCK'), ('ASSTGRP', 'ASSTGRP'), ('ASSTSTOCKSUP', 'ASSTSTOCKSUP'), ('RPTTYPE', 'RPTTYPE'), ('RPT', 'RPT'), ('FRMASSET', 'FRMASSET')], default='USER', max_length=100),
+        ),
+        migrations.AddField(
+            model_name='amsreport',
+            name='report_type',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='report_to_report_type', to='entities.AMSReportType', to_field='code'),
+        ),
+        migrations.AddField(
+            model_name='amsasset',
+            name='asset_type',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='ams_asset_type', to='entities.AMSAssetType', to_field='code'),
+        ),
+        migrations.AddField(
+            model_name='amsasset',
+            name='created_by',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='ams_asset_created_by', to=settings.AUTH_USER_MODEL, to_field='code'),
+        ),
+    ]

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/entities/models.py

@@ -1246,30 +1246,96 @@ class ChangeRequestSettings(models.Model):
 **********************
 """
 
-class AssetGroup(models.Model):
+class AMSPrivilege(models.Model):
+    id_number = models.ForeignKey(
+        User,
+        on_delete=models.PROTECT,
+        to_field='code',
+        related_name='ams_privilege_id_number'
+    )
+    department = models.ForeignKey(
+        Department,
+        on_delete=models.PROTECT,
+        related_name='ams_privilege_departments',
+        to_field='code'
+    )
+    ams_user_type = models.CharField(
+        choices=[(tag.value, tag.value) for tag in enums.AMSUserTypeEnum],
+        default=enums.AMSUserTypeEnum.MANAGER.value,
+        max_length=100
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+    deleted_at = models.DateTimeField(null=True, blank=True)
+    
+    class Meta:
+        db_table = 'ams_privileges'
+        unique_together = ['department', 'id_number']
+
+
+class AMSAssetGroup(models.Model):
     code = models.CharField(
         unique=True,
         max_length=255)
     name = models.CharField(
         unique=True,
         max_length=255)
-    asset_group = models.CharField(
+    created_by = models.ForeignKey(
+        User,
+        on_delete=models.PROTECT,
+        to_field='code',
+        related_name='ams_asset_group_created_by'
+    )
+    created = models.DateTimeField(auto_now_add=True)
+    is_active = models.BooleanField(default=True)
+    
+    class Meta:
+        db_table = 'ams_asset_groups'
+        ordering = ['-created']
+    
+    def __str__(self):
+        return f'{self.code}'
+
+    def save(self, *args, **kwargs):
+        super(AMSAssetGroup, self).save(*args, **kwargs)
+        code = number_generator(enums.GenerateCode.ASSET_GROUP.value, self.id)
+        
+        if self.code == '':
+            self.code = code
+            self.created = datetime.now()
+            self.save()
+
+
+class AMSAssetType(models.Model):
+
+    code = models.CharField(
         unique=True,
         max_length=255)
-    created = models.DateTimeField(
+    name = models.CharField(
+        unique=True,
+        max_length=255)
+    dynamic_field = models.TextField(
         blank=True,
-        null=True)
+        null=True
+    )
+    created_by = models.ForeignKey(
+        User,
+        on_delete=models.PROTECT,
+        to_field='code',
+        related_name='ams_asset_type_created_by'
+    )
+    created = models.DateTimeField(auto_now_add=True)
+    is_active = models.BooleanField(default=True)
     
     class Meta:
-        db_table = 'asset_groups'
+        db_table = 'ams_asset_types'
         ordering = ['-created']
 
     def __str__(self):
         return f'{self.code}'
 
     def save(self, *args, **kwargs):
-        super(AssetGroup, self).save(*args, **kwargs)
-        code = number_generator(enums.GenerateCode.ASSET_GROUP.value, self.id)
+        super(AMSAssetType, self).save(*args, **kwargs)
+        code = number_generator(enums.GenerateCode.ASSET_TYPE.value, self.id)
         
         if self.code == '':
             self.code = code
@@ -1277,211 +1343,339 @@ class AssetGroup(models.Model):
             self.save()
 
 
-class AMSPrivilege(models.Model):
-    id_number = models.ForeignKey(
+class AMSAsset(models.Model):
+
+    code = models.CharField(
+        unique=True,
+        max_length=255,
+        default='')
+    name = models.CharField(
+        unique=True,
+        max_length=255)
+    asset_type = models.ForeignKey(
+        AMSAssetType,
+        on_delete=models.PROTECT,
+        to_field='code',
+        related_name='ams_asset_type'
+    )
+    description = models.CharField(
+        blank=True,
+        null=True,
+        max_length=255)
+    created_by = models.ForeignKey(
+        User,
+        on_delete=models.PROTECT,
+        to_field='code',
+        related_name='ams_asset_created_by'
+    )
+    created = models.DateTimeField(auto_now_add=True)
+    is_active = models.BooleanField(default=True)
+    
+    class Meta:
+        db_table = 'ams_assets'
+        ordering = ['-created']
+
+    def __str__(self):
+        return f'{self.code}'
+
+    def save(self, *args, **kwargs):
+        super(AMSAsset, self).save(*args, **kwargs)
+        code = number_generator(enums.GenerateCode.ASSET.value, self.id)
+        
+        if self.code == '':
+            self.code = code
+            self.created = datetime.now()
+            self.save()
+
+
+class AMSAssetStock(models.Model):
+
+    code = models.CharField(
+        unique=True,
+        max_length=255,
+        default='')
+    unique_identifier = models.CharField(
+        unique=True,
+        max_length=255)
+    status = models.CharField(
+        choices=[(tag.value, tag.value) for tag in enums.AMSAssetStatus],
+        default=enums.AMSAssetStatus.INSTORE.value,
+        max_length=100
+    )
+    acquisition_type = models.CharField(
+        choices=[(tag.value, tag.value) for tag in enums.AMSAssetAquisitionType],
+        default=enums.AMSAssetAquisitionType.OWN.value,
+        max_length=100
+    )
+    location = models.CharField(
+        max_length=255
+    )
+    user_client = models.ForeignKey(
+        User,
+        on_delete=models.PROTECT,
+        to_field='code',
+        related_name='ams_asset_user_client'
+    )
+    manager = models.ForeignKey(
+        User,
+        on_delete=models.PROTECT,
+        to_field='code',
+        related_name='ams_asset_manager'
+    )
+    dynamic_field = models.TextField(
+        blank=True,
+        null=True
+    )
+    asset = models.ForeignKey(
+        AMSAsset,
+        on_delete=models.PROTECT,
+        to_field='code',
+        related_name='ams_asset_to_assetdetail'
+    )
+    asset_group = models.ForeignKey(
+        AMSAssetGroup,
+        on_delete=models.PROTECT,
+        to_field='code',
+        related_name='ams_asset_to_assetgroup'
+    )
+    created = models.DateTimeField(auto_now_add=True)
+    is_active = models.BooleanField(default=True)
+    
+    class Meta:
+        db_table = 'ams_asset_stocks'
+        ordering = ['-created']
+
+    def __str__(self):
+        return f'{self.code}'
+
+    def save(self, *args, **kwargs):
+        super(AMSAssetStock, self).save(*args, **kwargs)
+        code = number_generator(enums.GenerateCode.ASSET_STOCK.value, self.id)
+        
+        if self.code == '':
+            self.code = code
+            self.created = datetime.now()
+            self.save()
+
+
+class AMSAssetStockSupport(models.Model):
+
+    code = models.CharField(
+        unique=True,
+        max_length=255)
+    name = models.CharField(
+        unique=True,
+        max_length=255)
+    start_date = models.DateTimeField(
+        null=True,
+        blank=True)
+    end_date = models.DateTimeField(
+        null=True,
+        blank=True)
+    created_by = models.ForeignKey(
         User,
         on_delete=models.CASCADE,
         to_field='code',
-        related_name='ams_privilege_id_number'
+        related_name='ams_asset_stock_created_by'
     )
-    department = models.ForeignKey(
-        Department,
+    asset_stock = models.ForeignKey(
+        AMSAssetStock,
         on_delete=models.CASCADE,
-        related_name='ams_privilege_departments',
         to_field='code'
     )
-    ams_user_type = models.CharField(
-        choices=[(tag.value, tag.value) for tag in enums.AMSUserTypeEnum],
-        default=enums.AMSUserTypeEnum.MANAGER.value,
-        max_length=100
+    created = models.DateTimeField(auto_now_add=True)
+    is_active = models.BooleanField(default=True)
+    
+    class Meta:
+        db_table = 'ams_asset_stock_supports'
+        ordering = ['-created']
+
+    def __str__(self):
+        return f'{self.code}'
+
+    def save(self, *args, **kwargs):
+        super(AMSAssetStockSupport, self).save(*args, **kwargs)
+        code = number_generator(enums.GenerateCode.ASSET_STOCK_SUPPORT.value, self.id)
+        
+        if self.code == '':
+            self.code = code
+            self.created = datetime.now()
+            self.save()
+
+
+class AMSReportType(models.Model):
+
+    code = models.CharField(
+        unique=True,
+        max_length=255,
+        default='')
+    name = models.CharField(
+        unique=True,
+        max_length=255)
+    description = models.CharField(
+        blank=True,
+        null=True,
+        max_length=255)
+    dynamic_field = models.TextField(
+        blank=True,
+        null=True
     )
-    created_at = models.DateTimeField(auto_now_add=True)
-    deleted_at = models.DateTimeField(null=True, blank=True)
+    created_by = models.ForeignKey(
+        User,
+        on_delete=models.CASCADE,
+        to_field='code',
+        related_name='ams_report_type_created_by'
+    )
+    created = models.DateTimeField(auto_now_add=True)
+    is_active = models.BooleanField(default=True)
     
     class Meta:
-        db_table = 'ams_privileges'
-        unique_together = ['department', 'id_number']
+        db_table = 'ams_report_types'
+        ordering = ['-created']
 
+    def __str__(self):
+        return f'{self.code}'
 
-# class AMSAssetGroup(models.Model):
-#     code = models.CharField(
-#         unique=True,
-#         max_length=255)
-#     name = models.CharField(
-#         unique=True,
-#         max_length=255)
-#     created_by = models.ForeignKey(
-#         User,
-#         on_delete=models.CASCADE,
-#         to_field='code',
-#         related_name='ams_asset_group_created_by'
-#     )
-#     created = models.DateTimeField(auto_now_add=True)
-#     deleted_at = models.DateTimeField(null=True, blank=True)
+    def save(self, *args, **kwargs):
+        super(AMSReportType, self).save(*args, **kwargs)
+        code = number_generator(enums.GenerateCode.REPORT_TYPE.value, self.id)
         
-#     class Meta:
-#         db_table = 'ams_asset_groups'
-#         ordering = ['-created']
-    
-#     def __str__(self):
-#         return f'{self.code}'
-
-#     def save(self, *args, **kwargs):
-#         super(AMSAssetGroup, self).save(*args, **kwargs)
-#         code = number_generator(enums.GenerateCode.ASSET_GROUP.value, self.id)
-        
-#         if self.code == '':
-#             self.code = code
-#             self.created = datetime.now()
-#             self.save()
-
-
-# class AMSAssetType(models.Model):
-
-#     code = models.CharField(
-#         unique=True,
-#         max_length=255)
-#     name = models.CharField(
-#         unique=True,
-#         max_length=255)
-#     dynamic_field = models.TextField(
-#         blank=True,
-#         null=True
-#     )
-#     created_by = models.ForeignKey(
-#         User,
-#         on_delete=models.CASCADE,
-#         to_field='code',
-#         related_name='ams_asset_type_created_by'
-#     )
-#     created = models.DateTimeField(auto_now_add=True)
-#     deleted_at = models.DateTimeField(null=True, blank=True)
+        if self.code == '':
+            self.code = code
+            self.created = datetime.now()
+            self.save()
 
-#     class Meta:
-#         db_table = 'ams_asset_types'
-#         ordering = ['-created']
-
-#     def __str__(self):
-#         return f'{self.code}'
-
-#     def save(self, *args, **kwargs):
-#         super(AMSAssetType, self).save(*args, **kwargs)
-#         code = number_generator(enums.GenerateCode.ASSET_TYPE.value, self.id)
-        
-#         if self.code == '':
-#             self.code = code
-#             self.created = datetime.now()
-#             self.save()
-
-
-# class AMSAsset(models.Model):
-
-#     code = models.CharField(
-#         unique=True,
-#         max_length=255)
-#     name = models.CharField(
-#         unique=True,
-#         max_length=255)
-#     asset_type = models.ForeignKey(
-#         AMSAssetType,
-#         on_delete=models.CASCADE,
-#         to_field='code',
-#         related_name='ams_asset_type'
-#     )
-#     description = models.CharField(
-#         blank=True,
-#         null=True,
-#         max_length=255)
-#     created_by = models.ForeignKey(
-#         User,
-#         on_delete=models.CASCADE,
-#         to_field='code',
-#         related_name='ams_asset_created_by'
-#     )
-#     created = models.DateTimeField(auto_now_add=True)
-#     deleted_at = models.DateTimeField(null=True, blank=True)
 
-#     class Meta:
-#         db_table = 'ams_assets'
-#         ordering = ['-created']
-
-#     def __str__(self):
-#         return f'{self.code}'
-
-#     def save(self, *args, **kwargs):
-#         super(AMSAsset, self).save(*args, **kwargs)
-#         code = number_generator(enums.GenerateCode.ASSET.value, self.id)
-        
-#         if self.code == '':
-#             self.code = code
-#             self.created = datetime.now()
-#             self.save()
-
-
-# class AMSAssetStock(models.Model):
-
-#     code = models.CharField(
-#         unique=True,
-#         max_length=255)
-#     unique_identifier = models.CharField(
-#         unique=True,
-#         max_length=255)
-#     status = models.CharField(
-#         choices=[(tag.value, tag.value) for tag in enums.AMSAssetStatus],
-#         default=enums.AMSAssetStatus.INSTORE.value,
-#         max_length=100
-#     )
-#     acquisition_type = models.CharField(
-#         choices=[(tag.value, tag.value) for tag in enums.AMSAssetAquisitionType],
-#         default=enums.AMSAssetAquisitionType.OWN.value,
-#         max_length=100
-#     )
-#     location = models.CharField(
-#         max_length=255
-#     )
-#     user_client = models.ForeignKey(
-#         User,
-#         on_delete=models.CASCADE,
-#         to_field='code',
-#         related_name='ams_asset_user_client'
-#     )
-#     manager = models.ForeignKey(
-#         User,
-#         on_delete=models.CASCADE,
-#         to_field='code',
-#         related_name='ams_asset_manager'
-#     )
-#     dynamic_field = models.TextField(
-#         blank=True,
-#         null=True
-#     )
-#     asset = models.ForeignKey(
-#         AMSAsset,
-#         on_delete=models.CASCADE,
-#         to_field='code'
-#     )
-#     asset_type = models.ForeignKey(
-#         AMSAssetType,
-#         on_delete=models.CASCADE,
-#         to_field='code'
-#     )
-#     created = models.DateTimeField(auto_now_add=True)
-#     deleted_at = models.DateTimeField(null=True, blank=True)
+class AMSReport(models.Model):
 
-#     class Meta:
-#         db_table = 'ams_asset_stocks'
-#         ordering = ['-created']
+    code = models.CharField(
+        unique=True,
+        max_length=255,
+        default='')
+    name = models.CharField(
+        unique=True,
+        max_length=255)
+    dynamic_field = models.TextField(
+        blank=True,
+        null=True
+    )
+    report_type = models.ForeignKey(
+        AMSReportType,
+        on_delete=models.CASCADE,
+        to_field='code',
+        related_name='report_to_report_type'
+    )
+    asset_stock = models.ForeignKey(
+        AMSAssetStock,
+        on_delete=models.CASCADE,
+        to_field='code',
+        related_name='report_to_asset_stock'
+    )
+    created_by = models.ForeignKey(
+        User,
+        on_delete=models.CASCADE,
+        to_field='code',
+        related_name='ams_report_created_by'
+    )
+    created = models.DateTimeField(auto_now_add=True)
+    is_active = models.BooleanField(default=True)
+    
+    class Meta:
+        db_table = 'ams_reports'
+        ordering = ['-created']
+
+    def __str__(self):
+        return f'{self.code}'
+
+    def save(self, *args, **kwargs):
+        super(AMSReport, self).save(*args, **kwargs)
+        code = number_generator(enums.GenerateCode.REPORT.value, self.id)
+        
+        if self.code == '':
+            self.code = code
+            self.created = datetime.now()
+            self.save()
+
+
+class AMSAuditTrail(models.Model):
+
+    code = models.CharField(
+        unique=True,
+        max_length=255)
+    name = models.CharField(
+        unique=True,
+        max_length=255)
+    description = models.CharField(
+        blank=True,
+        null=True,
+        max_length=255)
+    asset_stock = models.ForeignKey(
+        AMSAssetStock,
+        on_delete=models.CASCADE,
+        to_field='code'
+    )
+    created_by = models.ForeignKey(
+        User,
+        on_delete=models.CASCADE,
+        to_field='code',
+        related_name='ams_audit_trail_created_by'
+    )
+    created = models.DateTimeField(auto_now_add=True)
+    deleted_at = models.DateTimeField(null=True, blank=True)
+    
+    class Meta:
+        db_table = 'ams_audit_trail'
+        ordering = ['-created']
 
-#     def __str__(self):
-#         return f'{self.code}'
+    def __str__(self):
+        return f'{self.code}'
 
-#     def save(self, *args, **kwargs):
-#         super(AMSAssetStock, self).save(*args, **kwargs)
-#         code = number_generator(enums.GenerateCode.ASSET_STOCK.value, self.id)
+    def save(self, *args, **kwargs):
+        super(AMSReport, self).save(*args, **kwargs)
+        code = number_generator(enums.GenerateCode.REPORT.value, self.id)
         
-#         if self.code == '':
-#             self.code = code
-#             self.created = datetime.now()
-#             self.save()
+        if self.code == '':
+            self.code = code
+            self.created = datetime.now()
+            self.save()
 
 
+class ChangeRequestFormAssets(models.Model):
+    code = models.CharField(
+        unique=True,
+        max_length=255)
+    form_code = models.ForeignKey(
+        ChangeRequestFormHeader,
+        on_delete=models.PROTECT,
+        to_field='form_code',
+        related_name='change_request_form_assets')
+    asset_stock = models.ForeignKey(
+        AMSAssetStock,
+        on_delete=models.CASCADE,
+        to_field='code'
+    )
+    created_by = models.ForeignKey(
+        User,
+        on_delete=models.CASCADE,
+        to_field='code',
+        related_name='cms_form_assets_created_by'
+    )
+    created = models.DateTimeField(auto_now_add=True)
+    deleted_at = models.DateTimeField(null=True, blank=True)
+
+
+    class Meta:
+        db_table = 'change_request_form_assets'
+        ordering = ['-created']
+
+    def __str__(self):
+        return f'{self.code}'
+
+    def save(self, *args, **kwargs):
+        super(ChangeRequestFormAssets, self).save(*args, **kwargs)
+        code = number_generator(enums.GenerateCode.FORM_ASSET.value, self.id)
+        
+        if self.code == '':
+            self.code = code
+            self.created = datetime.now()
+            self.save()
\ No newline at end of file

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,,,,,,,,,

requirements/RMSv2.postman_collection.json

 {
 	"info": {
-		"_postman_id": "c5ad0726-f9e0-4795-88d2-924ab3aa1201",
+		"_postman_id": "4003aad5-0e38-415c-95fc-84a0c8bb6607",
 		"name": "RMSv2",
 		"schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
 	},
@@ -802,7 +802,7 @@
 										],
 										"body": {
 											"mode": "raw",
-											"raw": "{\r\n\t\"application\":[\"APP-20190923-0000002\"],\r\n\t\"department\": \"\",\r\n\t\"user_type\": \"OUA\",\r\n\t\"name\": \"ss\",\r\n\t\"username\": \"jtc-sereness\",\r\n\t\"doa\":\"\",\r\n\t\"default_app\": \"APP-20190923-0000002\",\r\n\t\"contact_no\": \"1312313\",\r\n\t\"email\": \"t@gmail.com\"\r\n}\r\n"
+											"raw": "{\r\n\t\"application\":[\"APP-20190923-0000002\"],\r\n\t\"department\": \"DEPARTMENT-20200122-0000002\",\r\n\t\"user_type\": \"OUA\",\r\n\t\"name\": \"ss\",\r\n\t\"username\": \"jtc-sereness\",\r\n\t\"doa\":\"\",\r\n\t\"default_app\": \"APP-20190923-0000002\",\r\n\t\"contact_no\": \"1312313\",\r\n\t\"email\": \"t@gmail.com\"\r\n}\r\n"
 										},
 										"url": {
 											"raw": "{{baseurl}}/management/users/",
@@ -832,17 +832,17 @@
 										],
 										"body": {
 											"mode": "raw",
-											"raw": "{\r\n\t\"application\":[\"APP-20190917-0000001\",\"APP-20190917-0000003\"],\r\n\t\"department\": \"DEPARTMENT-20190917-0000002\",\r\n\t\"user_type\": \"OUA\",\r\n\t\"name\": \"Ritas\",\r\n\t\"username\": \"obrit1a\",\r\n\t\"doa\":\"\",\r\n\t\"default_app\": \"APP-20190917-0000001\",\r\n\t\"contact_no\": \"1312313\",\r\n\t\"email\": \"test@gmail.com\"\r\n}\r\n"
+											"raw": "{\r\n\t\"application\":[\"APP-20190923-0000001\"],\r\n\t\"department\": \"DEPARTMENT-20200122-0000002\",\r\n\t\"user_type\": \"OUA\",\r\n\t\"name\": \"Ritas\",\r\n\t\"username\": \"obrita\",\r\n\t\"doa\":\"\",\r\n\t\"default_app\": \"APP-20190923-0000001\",\r\n\t\"contact_no\": \"1312313\",\r\n\t\"email\": \"test@gmail.com\"\r\n}\r\n"
 										},
 										"url": {
-											"raw": "{{baseurl}}/management/users/USER-20190919-0000028/",
+											"raw": "{{baseurl}}/management/users/USER-20200122-0000002/",
 											"host": [
 												"{{baseurl}}"
 											],
 											"path": [
 												"management",
 												"users",
-												"USER-20190919-0000028",
+												"USER-20200122-0000002",
 												""
 											]
 										}
@@ -2666,7 +2666,7 @@
 										],
 										"body": {
 											"mode": "raw",
-											"raw": "{\r\n\t\"requested_to_template_name\": \"sdsd\",\r\n\t\"requested_to_template_id\": \"sdfssdddasdaesdf\",\r\n\t\"requested_to_objective\": \"Sample Objective\",\r\n\t\"requested_to_target_date\": \"34\",\r\n\t\"requested_to_priority\": \"Normal\",\r\n\t\"description\": \"Lorem Ipsum\",\r\n\t\"created_by_department\": \"DEPARTMENT-20200122-0000002\",\r\n\t\"created_by_user\": \"USER-20190923-0000001\",\r\n\t\"requested_to_company\": \"COMPANY-20190923-0000001\",\r\n\t\"requested_to_department\": \"DEPARTMENT-20200122-0000002\",\r\n\t\"requested_to_user\": \"USER-20200122-0000002\",\r\n\t\"html_desc\": \"desc\",\r\n\t\"html_obj\": \"obj\",\r\n\t\r\n\t\"tmp_approvers\": [\r\n\t\t{\r\n            \"level\": 1,\r\n            \"is_default\": true,\r\n            \"user\": \"USER-20200122-0000004\",\r\n            \"delegation\": \"\"\r\n\t\t},\r\n\t\t{\r\n            \"level\": 2,\r\n            \"is_default\": true,\r\n            \"user\": \"USER-20200122-0000002\",\r\n            \"delegation\": \"DELEGATION-20191119-0000002\"\r\n\t\t},\r\n\t\t{\r\n            \"level\": 3,\r\n            \"is_default\": true,\r\n            \"user\": \"USER-20190923-0000001\",\r\n            \"delegation\": \"DELEGATION-20191119-0000001\"\r\n\t\t}\r\n\t],\r\n\t\r\n\t\"tmp_stakes\": [\r\n\t\t{\r\n\t\t\t\"delegation\": \"Mandatory Stakeholder\",\r\n\t\t\t\"user\": \"USER-20200122-0000004\"\r\n\t\t}\r\n\t],\r\n\t\r\n\t\"tmp_attachments\": [\r\n\t],\r\n\t\"tmp_details\": []\r\n}"
+											"raw": "{\r\n\t\"requested_to_template_name\": \"\",\r\n\t\"requested_to_template_id\": \"sdfssdddasdaesdf\",\r\n\t\"requested_to_objective\": \"Sample Objective\",\r\n\t\"requested_to_target_date\": \"34\",\r\n\t\"requested_to_priority\": \"Normal\",\r\n\t\"description\": \"Lorem Ipsum\",\r\n\t\"created_by_department\": \"DEPARTMENT-20200122-0000002\",\r\n\t\"created_by_user\": \"USER-20190923-0000001\",\r\n\t\"requested_to_company\": \"COMPANY-20190923-0000001\",\r\n\t\"requested_to_department\": \"DEPARTMENT-20200122-0000002\",\r\n\t\"requested_to_user\": \"USER-20200122-0000002\",\r\n\t\"html_desc\": \"desc\",\r\n\t\"html_obj\": \"obj\",\r\n\t\r\n\t\"tmp_approvers\": [\r\n\t\t{\r\n            \"level\": 1,\r\n            \"is_default\": true,\r\n            \"user\": \"USER-20200122-0000004\",\r\n            \"delegation\": \"\"\r\n\t\t},\r\n\t\t{\r\n            \"level\": 2,\r\n            \"is_default\": true,\r\n            \"user\": \"USER-20200122-0000002\",\r\n            \"delegation\": \"DELEGATION-20191119-0000002\"\r\n\t\t},\r\n\t\t{\r\n            \"level\": 3,\r\n            \"is_default\": true,\r\n            \"user\": \"USER-20190923-0000001\",\r\n            \"delegation\": \"DELEGATION-20191119-0000001\"\r\n\t\t}\r\n\t],\r\n\t\r\n\t\"tmp_stakes\": [\r\n\t\t{\r\n\t\t\t\"delegation\": \"Mandatory Stakeholder\",\r\n\t\t\t\"user\": \"USER-20200122-0000004\"\r\n\t\t}\r\n\t],\r\n\t\r\n\t\"tmp_attachments\": [\r\n\t],\r\n\t\"tmp_details\": []\r\n}"
 										},
 										"url": {
 											"raw": "{{baseurl}}/change-request/template-post/",
@@ -3226,12 +3226,7 @@
 								],
 								"body": {
 									"mode": "raw",
-									"raw": "{\n\t\"cms_settings\": [\n        {\n            \"behalf_approved\": true,\n            \"behalf_accepted\": true,\n            \"behalf_rejected\": true,\n            \"behalf_implemented\": true,\n            \"behalf_completed\": true,\n            \"behalf_user\": \"USER-20200122-0000005\"\n        },\n        {\n            \"behalf_approved\": true,\n            \"behalf_accepted\": true,\n            \"behalf_rejected\": true,\n            \"behalf_implemented\": true,\n            \"behalf_completed\": true,\n            \"behalf_user\": \"USER-20200122-0000002\"\n        },\n        {\n            \"behalf_approved\": true,\n            \"behalf_accepted\": true,\n            \"behalf_rejected\": true,\n            \"behalf_implemented\": true,\n            \"behalf_completed\": true,\n            \"behalf_user\": \"USER-20200122-0000005\"\n        }\n    ]\n}",
-									"options": {
-										"raw": {
-											"language": "json"
-										}
-									}
+									"raw": "{\n\t\"cms_settings\": [\n        {\n            \"behalf_approved\": true,\n            \"behalf_accepted\": true,\n            \"behalf_rejected\": true,\n            \"behalf_implemented\": true,\n            \"behalf_completed\": true,\n            \"behalf_user\": \"USER-20200122-0000005\"\n        },\n        {\n            \"behalf_approved\": true,\n            \"behalf_accepted\": true,\n            \"behalf_rejected\": true,\n            \"behalf_implemented\": true,\n            \"behalf_completed\": true,\n            \"behalf_user\": \"USER-20200122-0000002\"\n        },\n        {\n            \"behalf_approved\": true,\n            \"behalf_accepted\": true,\n            \"behalf_rejected\": true,\n            \"behalf_implemented\": true,\n            \"behalf_completed\": true,\n            \"behalf_user\": \"USER-20200122-0000005\"\n        }\n    ]\n}"
 								},
 								"url": {
 									"raw": "{{baseurl}}/change-request/cms-settings/",
@@ -3461,7 +3456,7 @@
 								"method": "GET",
 								"header": [],
 								"url": {
-									"raw": "{{baseurl}}/asset-management/ams-privilege/",
+									"raw": "{{baseurl}}/asset-management/ams-privilege/?id_number=USER-20200311-0000007",
 									"host": [
 										"{{baseurl}}"
 									],
@@ -3469,6 +3464,12 @@
 										"asset-management",
 										"ams-privilege",
 										""
+									],
+									"query": [
+										{
+											"key": "id_number",
+											"value": "USER-20200311-0000007"
+										}
 									]
 								}
 							},
@@ -3481,12 +3482,7 @@
 								"header": [],
 								"body": {
 									"mode": "raw",
-									"raw": "{\n\t\"body_data\": [\n        {\n            \"id_number\": \"USER-20200122-0000002\",\n            \"department\": \"DEPARTMENT-20200122-0000003\",\n            \"ams_user_type\": \"MANAGER\"\n        },\n        {\n            \"id_number\": \"USER-20200122-0000002\",\n            \"department\": \"DEPARTMENT-20200122-0000002\",\n            \"ams_user_type\": \"USER_CLIENT\"\n        }\n    ]\n}",
-									"options": {
-										"raw": {
-											"language": "json"
-										}
-									}
+									"raw": "{\n\t\"form\": [\n        {\n            \"id_number\": \"USER-20200310-0000016\",\n            \"department\": \"DEPARTMENT-20200218-0000003\",\n            \"ams_user_type\": \"MANAGER\"\n        },\n        {\n            \"id_number\": \"USER-20200310-0000016\",\n            \"department\": \"DEPARTMENT-20200211-0000002\",\n            \"ams_user_type\": \"MANAGER\"\n        }\n    ]\n}"
 								},
 								"url": {
 									"raw": "{{baseurl}}/asset-management/ams-privilege/",
@@ -3509,6 +3505,45 @@
 				{
 					"name": "Asset Groups",
 					"item": [
+						{
+							"name": "List Asset Group",
+							"request": {
+								"method": "GET",
+								"header": [],
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-group/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-group",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "View Asset Group",
+							"request": {
+								"method": "GET",
+								"header": [],
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-group/ASSTGRP-20200317-0000001/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-group",
+										"ASSTGRP-20200317-0000001",
+										""
+									]
+								}
+							},
+							"response": []
+						},
 						{
 							"name": "Create Asset Group",
 							"request": {
@@ -3523,7 +3558,7 @@
 								],
 								"body": {
 									"mode": "raw",
-									"raw": "{\n\t\"name\": \"Asset Group 1\",\n\t\"asset_group\": \"JTC\"\n}"
+									"raw": "{\n\t\"name\": \"\"\n}"
 								},
 								"url": {
 									"raw": "{{baseurl}}/asset-management/asset-group/",
@@ -3553,17 +3588,69 @@
 								],
 								"body": {
 									"mode": "raw",
-									"raw": "{\n\t\"name\": \"Asset Group 3\",\n\t\"asset_group\": \"JTCs\"\n}"
+									"raw": "{\r\n    \"name\": \"Asset Group 1\"\r\n}"
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-group/ASSTGRP-20200317-0000001/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-group",
+										"ASSTGRP-20200317-0000001",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Archive List",
+							"request": {
+								"method": "GET",
+								"header": [],
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-group/archived/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-group",
+										"archived",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Restore of Asset Group",
+							"request": {
+								"method": "PATCH",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"type": "text",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": ""
 								},
 								"url": {
-									"raw": "{{baseurl}}/asset-management/asset-group/AMSGRP-20191025-0000002/",
+									"raw": "{{baseurl}}/asset-management/asset-group/ASSTGRP-20200319-0000003/restore/",
 									"host": [
 										"{{baseurl}}"
 									],
 									"path": [
 										"asset-management",
 										"asset-group",
-										"AMSGRP-20191025-0000002",
+										"ASSTGRP-20200319-0000003",
+										"restore",
 										""
 									]
 								}
@@ -3580,34 +3667,74 @@
 									"raw": ""
 								},
 								"url": {
-									"raw": "{{baseurl}}/asset-management/asset-group/AMSGRP-20191025-0000002/",
+									"raw": "{{baseurl}}/asset-management/asset-group/ASSTGRP-20200319-0000002/",
 									"host": [
 										"{{baseurl}}"
 									],
 									"path": [
 										"asset-management",
 										"asset-group",
-										"AMSGRP-20191025-0000002",
+										"ASSTGRP-20200319-0000002",
 										""
 									]
 								}
 							},
 							"response": []
+						}
+					],
+					"protocolProfileBehavior": {},
+					"_postman_isSubFolder": true
 				},
 				{
-							"name": "View Asset Group",
+					"name": "Asset Type",
+					"item": [
+						{
+							"name": "List of Asset Type",
+							"protocolProfileBehavior": {
+								"disableBodyPruning": true
+							},
+							"request": {
+								"method": "GET",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"value": "application/json",
+										"type": "text"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n\t\"name\": \"cctv\",\n\t\"dynamic_field\": \"\",\n\t\"created_by\": \"USER-20190923-0000001\"\n}"
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-type/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-type",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "View Asset Type",
 							"request": {
 								"method": "GET",
 								"header": [],
 								"url": {
-									"raw": "{{baseurl}}/asset-management/asset-group/AMSGRP-20191025-0000002/",
+									"raw": "{{baseurl}}/asset-management/asset-type/ASSTTYPE-20200318-0000010/",
 									"host": [
 										"{{baseurl}}"
 									],
 									"path": [
 										"asset-management",
-										"asset-group",
-										"AMSGRP-20191025-0000002",
+										"asset-type",
+										"ASSTTYPE-20200318-0000010",
 										""
 									]
 								}
@@ -3615,18 +3742,119 @@
 							"response": []
 						},
 						{
-							"name": "List Asset Group",
+							"name": "Create of Asset Type",
+							"request": {
+								"method": "POST",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"type": "text",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n\t\"name\": \"cctv12\",\n\t\"dynamic_fied\": \"\"\n}"
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-type/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-type",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Edit Asset Type",
+							"request": {
+								"method": "PUT",
+								"header": [],
+								"body": {
+									"mode": "raw",
+									"raw": "{\r\n    \"name\": \"cctv17\",\r\n    \"dynamic_field\": null\r\n}",
+									"options": {
+										"raw": {
+											"language": "json"
+										}
+									}
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-type/ASSTTYPE-20200318-0000010/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-type",
+										"ASSTTYPE-20200318-0000010",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Delete Asset Type",
+							"request": {
+								"method": "DELETE",
+								"header": [],
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-type/ASSTTYPE-20200318-0000010/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-type",
+										"ASSTTYPE-20200318-0000010",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Archive List",
 							"request": {
 								"method": "GET",
 								"header": [],
 								"url": {
-									"raw": "{{baseurl}}/asset-management/asset-group/",
+									"raw": "{{baseurl}}/asset-management/asset-type/archived/",
 									"host": [
 										"{{baseurl}}"
 									],
 									"path": [
 										"asset-management",
-										"asset-group",
+										"asset-type",
+										"archived",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Restore of Asset Type",
+							"request": {
+								"method": "PATCH",
+								"header": [],
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-type/ASSTTYPE-20200318-0000003/restore/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-type",
+										"ASSTTYPE-20200318-0000003",
+										"restore",
 										""
 									]
 								}
@@ -3636,6 +3864,907 @@
 					],
 					"protocolProfileBehavior": {},
 					"_postman_isSubFolder": true
+				},
+				{
+					"name": "Asset",
+					"item": [
+						{
+							"name": "List of Asset",
+							"request": {
+								"method": "GET",
+								"header": [],
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "List of  Archived Asset",
+							"request": {
+								"method": "GET",
+								"header": [],
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset/archived/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset",
+										"archived",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "View of Asset",
+							"request": {
+								"method": "GET",
+								"header": [],
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset/ASST-20200319-0000006/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset",
+										"ASST-20200319-0000006",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Stock List",
+							"request": {
+								"method": "GET",
+								"header": [],
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset/ASST-20200319-0000006/stock-list/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset",
+										"ASST-20200319-0000006",
+										"stock-list",
+										""
+									]
+								},
+								"description": "List of Stocks under a specific asset"
+							},
+							"response": []
+						},
+						{
+							"name": "Delete of Asset",
+							"request": {
+								"method": "DELETE",
+								"header": [],
+								"body": {
+									"mode": "raw",
+									"raw": ""
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset/ASST-20200318-0000005/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset",
+										"ASST-20200318-0000005",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Restore of Asset",
+							"request": {
+								"method": "PATCH",
+								"header": [],
+								"body": {
+									"mode": "raw",
+									"raw": ""
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset/ASST-20200318-0000005/restore/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset",
+										"ASST-20200318-0000005",
+										"restore",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Create of Asset",
+							"request": {
+								"method": "POST",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"type": "text",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n\t\"name\": \"g1a\",\n\t\"asset_type\": \"ASSTTYPE-20200318-0000003\"\n}"
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Edit Asset",
+							"request": {
+								"method": "PUT",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"type": "text",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n\t\"name\": \"update\",\n\t\"asset_type\": \"ASSTTYPE-20200318-0000003\"\n}\t"
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset/ASST-20200319-0000006/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset",
+										"ASST-20200319-0000006",
+										""
+									]
+								}
+							},
+							"response": []
+						}
+					],
+					"protocolProfileBehavior": {},
+					"_postman_isSubFolder": true
+				},
+				{
+					"name": "Asset Stock",
+					"item": [
+						{
+							"name": "List of Asset Stock",
+							"request": {
+								"method": "GET",
+								"header": [],
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-stock/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-stock",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Archive List",
+							"request": {
+								"method": "GET",
+								"header": [],
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-stock/archived/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-stock",
+										"archived",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "View of Asset Stock",
+							"request": {
+								"method": "GET",
+								"header": [],
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-stock/ASSTSTOCK-20200319-0000008/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-stock",
+										"ASSTSTOCK-20200319-0000008",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Delete of Asset Stock",
+							"request": {
+								"method": "DELETE",
+								"header": [],
+								"body": {
+									"mode": "raw",
+									"raw": ""
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-stock/ASSTSTOCK-20200319-0000005/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-stock",
+										"ASSTSTOCK-20200319-0000005",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Restore of Asset Stock",
+							"request": {
+								"method": "PATCH",
+								"header": [],
+								"body": {
+									"mode": "raw",
+									"raw": ""
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-stock/ASSTSTOCK-20200319-0000005/restore/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-stock",
+										"ASSTSTOCK-20200319-0000005",
+										"restore",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Update of Asset Stock",
+							"request": {
+								"method": "PUT",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"value": "application/json",
+										"type": "text"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n\t\"asset_type\": \"ASSTTYPE-20200317-0000001\",\n\t\"unique_identifier\": \"ph\",\n\t\"status\": \"In-Store\",\n\t\"acquisition_type\": \"Owned\",\n\t\"location\" : \"Country Space\",\n\t\"user_client\": \"USER-20190923-0000001\",\n\t\"manager\": \"USER-20190923-0000001\",\n\t\"dynamic_field\": \"\",\n\t\"asset\": \"ASST-20200319-0000006\",\n\t\"asset_group\": \"ASSTGRP-20200319-0000002\"\n\t\n\t\n}\n"
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-stock/ASSTSTOCK-20200319-0000008/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-stock",
+										"ASSTSTOCK-20200319-0000008",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Create of Asset Stock",
+							"request": {
+								"method": "POST",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"type": "text",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n\t\"asset_type\": \"ASSTTYPE-20200317-0000001\",\n\t\"unique_identifier\": \"ph-002112\",\n\t\"status\": \"In-Store\",\n\t\"acquisition_type\": \"Owned\",\n\t\"location\" : \"Country Space\",\n\t\"user_client\": \"USER-20190923-0000001\",\n\t\"manager\": \"USER-20190923-0000001\",\n\t\"dynamic_field\": \"\",\n\t\"asset\": \"ASST-20200319-0000006\",\n\t\"asset_group\": \"ASSTGRP-20200319-0000002\"\n\t\n\t\n}\n"
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-stock/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-stock",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Dashboard",
+							"request": {
+								"method": "GET",
+								"header": [],
+								"url": {
+									"raw": "{{baseurl}}/asset-management/asset-stock/dashboard",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"asset-stock",
+										"dashboard"
+									]
+								}
+							},
+							"response": []
+						}
+					],
+					"event": [
+						{
+							"listen": "prerequest",
+							"script": {
+								"id": "288599a1-e537-45fe-ab0b-6af0b6abe0b0",
+								"type": "text/javascript",
+								"exec": [
+									""
+								]
+							}
+						},
+						{
+							"listen": "test",
+							"script": {
+								"id": "3f03e962-e3bc-4194-a78d-16f9859cc02a",
+								"type": "text/javascript",
+								"exec": [
+									""
+								]
+							}
+						}
+					],
+					"protocolProfileBehavior": {},
+					"_postman_isSubFolder": true
+				},
+				{
+					"name": "Report Type",
+					"item": [
+						{
+							"name": "List of Report Type",
+							"protocolProfileBehavior": {
+								"disableBodyPruning": true
+							},
+							"request": {
+								"method": "GET",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"value": "application/json",
+										"type": "text"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n\t\"name\": \"cctv\",\n\t\"dynamic_field\": \"\",\n\t\"created_by\": \"USER-20190923-0000001\"\n}"
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/report-type/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"report-type",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "View of ReportType",
+							"protocolProfileBehavior": {
+								"disableBodyPruning": true
+							},
+							"request": {
+								"method": "GET",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"value": "application/json",
+										"type": "text"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": ""
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/report-type/RPTTYPE-20200318-0000001/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"report-type",
+										"RPTTYPE-20200318-0000001",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Archived of ReportType",
+							"protocolProfileBehavior": {
+								"disableBodyPruning": true
+							},
+							"request": {
+								"method": "GET",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"value": "application/json",
+										"type": "text"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n\t\"name\": \"cctv\",\n\t\"dynamic_field\": \"\",\n\t\"created_by\": \"USER-20190923-0000001\"\n}"
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/report-type/archived/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"report-type",
+										"archived",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Create of Report Type",
+							"request": {
+								"method": "POST",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"type": "text",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n\t\"name\": \"incident\",\n\t\"dynamic_field\": \"wowo\",\n\t\"description\": \"this is a test for report type\"\n}"
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/report-type/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"report-type",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Update of Report Type",
+							"request": {
+								"method": "PUT",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"type": "text",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n\t\"name\": \"incident\",\n\t\"dynamic_field\": \"\",\n\t\"description\": \"this is a test for report type\"\n}"
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/report-type/RPTTYPE-20200318-0000001/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"report-type",
+										"RPTTYPE-20200318-0000001",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Delete of Report Type",
+							"request": {
+								"method": "DELETE",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"type": "text",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": ""
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/report-type/RPTTYPE-20200318-0000001/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"report-type",
+										"RPTTYPE-20200318-0000001",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Restore of Report Type",
+							"request": {
+								"method": "PATCH",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"type": "text",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": ""
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/report-type/RPTTYPE-20200318-0000001/restore/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"report-type",
+										"RPTTYPE-20200318-0000001",
+										"restore",
+										""
+									]
+								}
+							},
+							"response": []
+						}
+					],
+					"protocolProfileBehavior": {},
+					"_postman_isSubFolder": true
+				},
+				{
+					"name": "Report",
+					"item": [
+						{
+							"name": "List of Report Type",
+							"protocolProfileBehavior": {
+								"disableBodyPruning": true
+							},
+							"request": {
+								"method": "GET",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"value": "application/json",
+										"type": "text"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": ""
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/report/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"report",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "View of ReportType",
+							"protocolProfileBehavior": {
+								"disableBodyPruning": true
+							},
+							"request": {
+								"method": "GET",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"value": "application/json",
+										"type": "text"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": ""
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/report/RPT-20200318-0000005/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"report",
+										"RPT-20200318-0000005",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Archived of ReportType",
+							"protocolProfileBehavior": {
+								"disableBodyPruning": true
+							},
+							"request": {
+								"method": "GET",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"value": "application/json",
+										"type": "text"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n\t\"name\": \"cctv\",\n\t\"dynamic_field\": \"\",\n\t\"created_by\": \"USER-20190923-0000001\"\n}"
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/report/archived/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"report",
+										"archived",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Create of Report Type",
+							"request": {
+								"method": "POST",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"type": "text",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n\t\"name\": \"Cam 17 downs\",\n\t\"dynamic_field\": \"\",\n\t\"description\": \"this is a test for report type\",\n\t\"report_type\": \"RPTTYPE-20200318-0000001\",\n\t\"asset_stock\": \"ASSTSTOCK-20200317-0000004\"\n}"
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/report/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"report",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Update of Report Type",
+							"request": {
+								"method": "PUT",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"type": "text",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": "{\n\t\"name\": \"Cam 17 downdds\",\n\t\"dynamic_field\": \"\",\n\t\"description\": \"this is a test for report type\",\n\t\"report_type\": \"RPTTYPE-20200318-0000001\",\n\t\"asset_stock\": \"ASSTSTOCK-20200317-0000004\"\n}"
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/report/RPT-20200318-0000005/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"report",
+										"RPT-20200318-0000005",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Delete of Report Type",
+							"request": {
+								"method": "DELETE",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"type": "text",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": ""
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/report/RPT-20200318-0000005/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"report",
+										"RPT-20200318-0000005",
+										""
+									]
+								}
+							},
+							"response": []
+						},
+						{
+							"name": "Restore of Report Type",
+							"request": {
+								"method": "PATCH",
+								"header": [
+									{
+										"key": "Content-Type",
+										"name": "Content-Type",
+										"type": "text",
+										"value": "application/json"
+									}
+								],
+								"body": {
+									"mode": "raw",
+									"raw": ""
+								},
+								"url": {
+									"raw": "{{baseurl}}/asset-management/report/RPT-20200318-0000005/restore/",
+									"host": [
+										"{{baseurl}}"
+									],
+									"path": [
+										"asset-management",
+										"report",
+										"RPT-20200318-0000005",
+										"restore",
+										""
+									]
+								}
+							},
+							"response": []
+						}
+					],
+					"event": [
+						{
+							"listen": "prerequest",
+							"script": {
+								"id": "dc05875a-6fd9-477c-a8bf-d5ac4385881b",
+								"type": "text/javascript",
+								"exec": [
+									""
+								]
+							}
+						},
+						{
+							"listen": "test",
+							"script": {
+								"id": "2a8cc892-4049-4c34-ad81-01ca77c4812b",
+								"type": "text/javascript",
+								"exec": [
+									""
+								]
+							}
+						}
+					],
+					"protocolProfileBehavior": {},
+					"_postman_isSubFolder": true
 				}
 			],
 			"protocolProfileBehavior": {}
@@ -3646,7 +4775,7 @@
 		"bearer": [
 			{
 				"key": "token",
-				"value": "4a6d5d4ce95b759f2718e64878d4be38d257022b",
+				"value": "c62f448746704fabc7094417bdb2bab4d635a68c",
 				"type": "string"
 			}
 		]