Merge branch 'RMSv2' of http://42.61.118.105:7990/scm/rms/api-main-service into gladys-dev2

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

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

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

+from rest_framework import serializers
+from app.entities import models
+from django.forms.models import model_to_dict
+
+
+class ChangeRequestTemplateAttachmentsSerializer(
+    serializers.ModelSerializer
+):
+    class Meta:
+        model = models.ChangeRequestTemplateAttachments
+        fields = '__all__'
+        read_only_fields = ['created', 'code']

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

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

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

+from app.entities import models
+from rest_framework import viewsets, status
+from rest_framework.response import Response
+from django_filters import rest_framework as filters
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.filters import SearchFilter, OrderingFilter
+from app.applicationlayer.cms.template.attachment.table_filters import AttachmentFilter
+from app.applicationlayer.cms.template.attachment import serializers
+from app.applicationlayer.utils import (
+    CustomPagination, status_message_response
+)
+
+
+class ChangeRequestTemplateAttachmentsViewset(viewsets.ModelViewSet):
+
+    queryset = models.ChangeRequestTemplateAttachments.objects.all()
+    serializer_class = serializers.ChangeRequestTemplateAttachmentsSerializer
+    pagination_class = CustomPagination
+    lookup_field = "code"
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    filterset_class = AttachmentFilter
+    ordering_fields = '__all__'
+    search_fields = (
+        'template_no', 'code',
+        'file_name',
+        'description',
+        'uploaded_by__name'
+    )
+
+    def list(self, request, *args, **kwargs):
+        
+        page = self.paginate_queryset(self.queryset)
+        
+        if page is not None:
+            serializer = self.get_serializer(page, many=True)
+
+            message = status_message_response(
+                200,
+                'success',
+                'List of Templates Attachments found',
+                serializer.data
+            )
+            
+            return self.get_paginated_response(message)
+
+        serializer = self.get_serializer(self.queryset, many=True)
+
+        return Response(
+            serializer.data,
+            status=status.HTTP_200_OK
+        )

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

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

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

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

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

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

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

+from app.entities import models
+from rest_framework import serializers
+from django.db.models import Q
+from django.forms.models import model_to_dict
+from drf_writable_nested import WritableNestedModelSerializer
+from app.applicationlayer.cms.utils_cr import (get_account_details,
+                                               get_dept_details,
+                                               get_companies_details)
+
+
+from app.applicationlayer.cms.template.approver.serializers import ChangeRequestTemplateApproversSerializer
+from app.applicationlayer.cms.template.stakeholder.serializers import ChangeRequestTemplateStakeHoldersSerializer
+
+
+class ChangeRequestTemplateAttachmentsSerializer(
+    serializers.ModelSerializer
+):
+    class Meta:
+        model = models.ChangeRequestTemplateAttachments
+        fields = '__all__'
+        read_only_fields = ['created', 'code']
+
+
+class ChangeRequestTemplateDetailsSerializer(
+    serializers.ModelSerializer
+):
+    class Meta:
+        model = models.ChangeRequestTemplateDetails
+        fields = '__all__'
+        read_only_fields = ['created', 'code']
+
+
+class ChangeRequestTemplatesSerializer(
+    serializers.ModelSerializer
+):
+    tmp_approvers = ChangeRequestTemplateApproversSerializer(
+        many=True, read_only=True)
+    tmp_stakes = ChangeRequestTemplateStakeHoldersSerializer(
+        many=True, read_only=True)
+    tmp_attachments = ChangeRequestTemplateAttachmentsSerializer(
+        many=True, read_only=True)
+    tmp_details = ChangeRequestTemplateDetailsSerializer(
+        many=True, read_only=True)
+
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)
+        try:
+
+            ret['company'] = model_to_dict(instance.user.department.company)
+            ret['department'] = model_to_dict(instance.user.department)
+            ret['point_of_contact'] = model_to_dict(instance.requested_to_user)
+            ret['created_by'] = instance.created_by_user.code
+
+            return ret
+        except Exception as e:
+
+            ret['company'] = "none"
+            ret['department'] = "none"
+            ret['point_of_contact'] = "none"
+            ret['created_by'] = "none"
+
+            return ret
+
+    class Meta:
+        model = models.ChangeRequestTemplateHeader
+        # fields = '__all__'
+        fields = ('template_no', 'requested_to_template_name',
+                  'requested_to_objective', 'requested_to_target_date',
+                  'requested_to_priority', 'description', 'created',
+                  'requested_to_template_id', 'requested_to_company',
+                  'requested_to_department', 'requested_to_user',
+                  'created_by_user', 'created_by_department',
+                  'tmp_approvers', 'tmp_stakes', 'tmp_attachments',
+                  'tmp_details')
+
+        read_only_fields = ['created', 'template_no']

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

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

app/applicationlayer/cms/template/views.py

-from django.shortcuts import render
-
 from rest_framework import viewsets as meviewsets
 from rest_framework.views import APIView
 from app.applicationlayer.cms.template import serializers
 
 from app.entities import models
-from app.applicationlayer import paginators
-
-from datetime import datetime
-from datetime import timedelta
 
 from rest_framework.response import Response
 from rest_framework import status, views
 
 from rest_framework.decorators import action
-from django.http import Http404
 
 from django.db.models import Q
-import requests
-from django.conf import settings
 from rest_framework.exceptions import ValidationError
-from django.db import transaction, IntegrityError, connection
-from app.applicationlayer.utils import (QuerySetHelper,
-                                        CustomPagination,
+from django.db import transaction
+from app.applicationlayer.utils import (CustomPagination,
                                         status_message_response)
-from app.businesslayer.changerequest import change_request
+
 from app.applicationlayer.cms.utils_cr import (
-    number_generator, crhistory_save, entity_log_bulk
+    entity_log_bulk
 )
-from django.shortcuts import get_object_or_404
-
-from rest_framework.generics import GenericAPIView
-from rest_framework.mixins import UpdateModelMixin
 from django.forms.models import model_to_dict
 from app.entities import enums, models
 from django.db.models import Q
 
-from app.applicationlayer.management.account.serializer import ChangeRequestList
 from app.applicationlayer.utils import log_save, CustomPagination
 from rest_framework.exceptions import ParseError
 from app.businesslayer.changerequest.change_request_template import (
     tmp_add_edit_delete
 )
-
+from app.applicationlayer.management.account.serializer import ChangeRequestList
+from app.applicationlayer.cms.template.approver.serializers import ChangeRequestTemplateApproversSerializer
+from app.applicationlayer.cms.template.stakeholder.serializers import ChangeRequestTemplateStakeHoldersSerializer
+from app.applicationlayer.cms.template.details.serializers import ChangeRequestTemplateDetailsSerializer
+from app.applicationlayer.cms.template.attachment.serializers import ChangeRequestTemplateAttachmentsSerializer
 
 class UserList(APIView):
 
@@ -223,9 +212,9 @@ class ChangeRequestTemplatesViewset(meviewsets.ModelViewSet):
         instance = self.get_object()
 
         template_no = kwargs['template_no']
-        
+
         body_data = request.data
-        
+
         tmp_no_exists = models.ChangeRequestFormHeader.objects.filter(
             template_no=template_no)
         
@@ -251,7 +240,7 @@ class ChangeRequestTemplatesViewset(meviewsets.ModelViewSet):
                 body_data['tmp_approvers'],
                 models.ChangeRequestTemplateApprovers,
                 enums.LogEntitiesEnum.ChangeRequestTemplateApprovers.value,
-                serializers.ChangeRequestTemplateApproversSerializer,
+                ChangeRequestTemplateApproversSerializer,
                 partial,
                 self,
                 template_no
@@ -261,7 +250,7 @@ class ChangeRequestTemplatesViewset(meviewsets.ModelViewSet):
                 body_data['tmp_stakes'],
                 models.ChangeRequestTemplateStakeHolders,
                 enums.LogEntitiesEnum.ChangeRequestTemplateStakeHolders.value,
-                serializers.ChangeRequestTemplateStakeHoldersSerializer,
+                ChangeRequestTemplateStakeHoldersSerializer,
                 partial,
                 self,
                 template_no
@@ -346,7 +335,7 @@ class ChangeRequestTemplatePost(APIView):
                 tmp_approver['template_no'] = tmp_id
                 data_list_approver.append(tmp_approver)
 
-            serializerApprover = serializers.ChangeRequestTemplateApproversSerializer(
+            serializerApprover = ChangeRequestTemplateApproversSerializer(
                 data=data_list_approver, many=True)
             
             if serializerApprover.is_valid(raise_exception=True):
@@ -360,7 +349,7 @@ class ChangeRequestTemplatePost(APIView):
                     tmp_stake['template_no'] = tmp_id
                     data_list_stake.append(tmp_stake)
 
-                serializerStake = serializers.ChangeRequestTemplateStakeHoldersSerializer(
+                serializerStake = ChangeRequestTemplateStakeHoldersSerializer(
                     data=data_list_stake, many=True)
 
                 if serializerStake.is_valid(raise_exception=True):
@@ -374,7 +363,7 @@ class ChangeRequestTemplatePost(APIView):
                     tmp_attachment['template_no'] = tmp_id
                     data_list_attach.append(tmp_attachment)
 
-                serializerAttach = serializers.ChangeRequestTemplateAttachmentsSerializer(
+                serializerAttach = ChangeRequestTemplateAttachmentsSerializer(
                     data=data_list_attach, many=True)
 
                 if serializerAttach.is_valid(raise_exception=True):
@@ -388,7 +377,7 @@ class ChangeRequestTemplatePost(APIView):
                     tmp_detail['template_no'] = tmp_id
                     data_list_detail.append(tmp_detail)
 
-                serializerDetail = serializers.ChangeRequestTemplateDetailsSerializer(
+                serializerDetail = ChangeRequestTemplateDetailsSerializer(
                     data=data_list_detail, many=True)
                 
                 if serializerDetail.is_valid(raise_exception=True):
@@ -421,72 +410,3 @@ class ChangeRequestTemplatePost(APIView):
             }
             return Response(message,
                             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-
-class ChangeRequestTemplateAttachmentsViewset(meviewsets.ModelViewSet):
-
-    queryset = models.ChangeRequestTemplateAttachments.objects.all()
-    serializer_class = serializers.ChangeRequestTemplateAttachmentsSerializer
-    pagination_class = CustomPagination
-    lookup_field = "code"
-    
-    def list(self, request, *args, **kwargs):
-        
-        self.queryset = self.queryset.order_by('-created')
-        self.queryset = QuerySetHelper.Sort(self)
-        
-        page = self.paginate_queryset(self.queryset)
-        
-        if page is not None:
-            serializer = self.get_serializer(page, many=True)
-
-            message = status_message_response(
-                200,
-                'success',
-                'List of Templates Attachments found',
-                serializer.data
-            )
-            
-            return self.get_paginated_response(message)
-
-        serializer = self.get_serializer(self.queryset, many=True)
-
-        return Response(
-            serializer.data,
-            status=status.HTTP_200_OK
-        )
-
-
-
-class ChangeRequestTemplateDetailsViewset(meviewsets.ModelViewSet):
-
-    queryset = models.ChangeRequestTemplateDetails.objects.all()
-    serializer_class = serializers.ChangeRequestTemplateDetailsSerializer
-    pagination_class = CustomPagination
-    lookup_field = "code"
-
-    def list(self, request, *args, **kwargs):
-        
-        self.queryset = self.queryset.order_by('-created')
-        self.queryset = QuerySetHelper.Sort(self)
-        
-        page = self.paginate_queryset(self.queryset)
-        
-        if page is not None:
-            serializer = self.get_serializer(page, many=True)
-
-            message = status_message_response(
-                200,
-                'success',
-                'List of Templates Details found',
-                serializer.data
-            )
-            
-            return self.get_paginated_response(message)
-
-        serializer = self.get_serializer(self.queryset, many=True)
-
-        return Response(
-            serializer.data,
-            status=status.HTTP_200_OK
-        )

app/applicationlayer/cms/urls_cms.py

@@ -4,25 +4,32 @@ from django.conf.urls import url
 
 from app.applicationlayer.management.notification.views import NotificationsViewset
 
-from app.applicationlayer.cms.template import views as crtemplate_views
 from app.applicationlayer.cms.form import views as crform_views
 from app.applicationlayer.cms.allowed_company import views as allowed
 
+# MASTERS
 from app.applicationlayer.cms.master.company.views import ChangeRequestCompanyViewSet
 from app.applicationlayer.cms.master.department.views import  ChangeRequestDepartmentViewSet
+from app.applicationlayer.cms.master.account.views import  UserList
+# MASTERS
 
+# TEMPLATE 
+from app.applicationlayer.cms.template.header import views as header
 from app.applicationlayer.cms.template.approver import views as approver
 from app.applicationlayer.cms.template.stakeholder import views as stakeholder
+from app.applicationlayer.cms.template.details import views as details
+from app.applicationlayer.cms.template.attachment import views as attachment
+# TEMPLATE 
 
 router = routers.DefaultRouter()
 
 router.register(r'notifications', NotificationsViewset)
 
-router.register(r'template', crtemplate_views.ChangeRequestTemplatesViewset)
+router.register(r'template', header.ChangeRequestTemplatesViewset)
 router.register(r'template-approvers', approver.ChangeRequestTemplateApproversViewset)
-router.register(r'template-attachments', crtemplate_views.ChangeRequestTemplateAttachmentsViewset)
+router.register(r'template-attachments', attachment.ChangeRequestTemplateAttachmentsViewset)
 router.register(r'template-stakeholders', stakeholder.ChangeRequestTemplateStakeholdersViewset)
-router.register(r'template-details', crtemplate_views.ChangeRequestTemplateDetailsViewset)
+router.register(r'template-details', details.ChangeRequestTemplateDetailsViewset)
 
 router.register(r'form', crform_views.ChangeRequestFormsViewset)
 router.register(r'form-approvers', crform_views.ChangeRequestFormApproversViewset)
@@ -42,9 +49,9 @@ router.register(r'departments', ChangeRequestDepartmentViewSet)
 
 urlpatterns = (
     path('', include(router.urls)),
-    path('template-post/', crtemplate_views.ChangeRequestTemplatePost.as_view()),
+    path('template-post/', header.ChangeRequestTemplatePost.as_view()),
     path('form-post/', crform_views.ChangeRequestFormPost.as_view()),
     # filter endpoints under Allowed Companies table
-    path('user-list/', crtemplate_views.UserList.as_view(), name="User List"),
+    path('user-list/', UserList.as_view(), name="User List"),
     # filter endpoints under Allowed Companies table
 )

app/applicationlayer/management/account/serializer.py

@@ -74,31 +74,32 @@ class ChangePasswordSerializer(serializers.Serializer):
 
         if validated_password:
 
-            password = re.match(
-                '([A-Za-z]+[0-9]|[0-9]+[A-Za-z])[A-Za-z0-9]*',
-                new_password
-            )
-            print("password")
-            print(password)
-            print(password)
+            # password = re.match(
+            #     '([A-Za-z]+[0-9]|[0-9]+[A-Za-z])[A-Za-z0-9]*',
+            #     new_password
+            # )
 
-            if password:
+            # if password:
 
-                new_password = make_password(new_password)
-                instance_password.update(password=new_password)
-                # instance = User.objects.get(code=str(instance))
-                return instance
+            #     new_password = make_password(new_password)
+            #     instance_password.update(password=new_password)
+            #     return instance
 
-            elif len(new_password) <= 5:
+            if len(new_password) <= 5:
 
                 raise serializers.ValidationError(
                     'Password must be minimum of 6 characters'
                 )
 
             else:
+                new_password = make_password(new_password)
+                instance_password.update(password=new_password)
+                return instance
 
-                raise serializers.ValidationError(
-                    'password must be alpha numeric format'
-                )
+            # else:
+
+            #     raise serializers.ValidationError(
+            #         'password must be alpha numeric format'
+            #     )
         else:
             raise serializers.ValidationError('Please ensure the old password is correct and both new password & confirm password are the same.')