Skip to content

R
red-ci-cd
Commit 12eee603 authored by Gladys Forte's avatar Gladys Forte
Browse files
Options

folder structure

parent eaaa987c
Hide whitespace changes
Inline Side-by-side
Showing with 1749 additions and 67 deletions
app/applicationlayer/cms/form/approver/serializers.py 0 → 100644
View file @ 12eee603
from app.entities import models
from rest_framework import serializers
from django.forms.models import model_to_dict
class ChangeRequestFormApproversSerializer(
serializers.ModelSerializer
):
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)
user_object = {
"id": instance.user.id,
"name": instance.user.name,
"username": instance.user.username,
"code": instance.user.code,
"email": instance.user.email,
"contact_no": instance.user.contact_no
}
ret['user'] = user_object
return ret
except Exception as e:
ret['user'] = "none"
ret['department'] = "none"
ret['company'] = "none"
return ret
class Meta:
model = models.ChangeRequestFormApprovers
fields = '__all__'
read_only_fields = ['created', 'code']
app/applicationlayer/cms/form/approver/table_filters.py 0 → 100644
View file @ 12eee603
from django_filters import rest_framework as filters
from app.entities.models import ChangeRequestFormApprovers
class ApproverFilter(filters.FilterSet):
class Meta:
model = ChangeRequestFormApprovers
fields = '__all__'
app/applicationlayer/cms/form/approver/views.py 0 → 100644
View file @ 12eee603
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.form.approver.table_filters import ApproverFilter
from app.applicationlayer.cms.form.approver import serializers
from app.applicationlayer.utils import (
CustomPagination, status_message_response
)
class ChangeRequestFormApproversViewset(viewsets.ModelViewSet):
queryset = models.ChangeRequestFormApprovers.objects.all()
serializer_class = serializers.ChangeRequestFormApproversSerializer
pagination_class = CustomPagination
lookup_field = 'code'
filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
filterset_class = ApproverFilter
ordering_fields = '__all__'
search_fields = (
'name', 'code',
'department__company__name',
'department__name',
'email', 'contact_no'
)
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 Form Approvers 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/cms/form/attachment/serializers.py 0 → 100644
View file @ 12eee603
from app.entities import models
from rest_framework import serializers
from django.forms.models import model_to_dict
class ChangeRequestFormAttachmentsSerializer(
serializers.ModelSerializer
):
def to_representation(self, instance):
try:
ret = super().to_representation(instance)
user_object = {
"id": instance.uploaded_by.id,
"name": instance.uploaded_by.name,
"username": instance.uploaded_by.username,
"code": instance.uploaded_by.code,
"email": instance.uploaded_by.email,
"contact_no": instance.uploaded_by.contact_no
}
ret['uploaded_by'] = user_object
return ret
except Exception as e:
ret['uploaded_by'] = "none"
return ret
class Meta:
model = models.ChangeRequestFormAttachments
fields = '__all__'
read_only_fields = ['created', 'code']
\ No newline at end of file
app/applicationlayer/cms/form/attachment/table_filters.py 0 → 100644
View file @ 12eee603
from django_filters import rest_framework as filters
from app.entities.models import ChangeRequestFormAttachments
class AttachmentFilter(filters.FilterSet):
class Meta:
model = ChangeRequestFormAttachments
fields = '__all__'
app/applicationlayer/cms/form/attachment/views.py 0 → 100644
View file @ 12eee603
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.form.attachment.table_filters import AttachmentFilter
from app.applicationlayer.cms.form.attachment import serializers
from app.applicationlayer.utils import (
CustomPagination, status_message_response
)
class ChangeRequestFormAttachmentsViewset(viewsets.ModelViewSet):
queryset = models.ChangeRequestFormAttachments.objects.all()
serializer_class = serializers.ChangeRequestFormAttachmentsSerializer
pagination_class = CustomPagination
lookup_field = "code"
filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
filterset_class = AttachmentFilter
ordering_fields = '__all__'
search_fields = (
'form_code', 'code',
'file_name',
'description',
'uploaded_by__name'
)
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 Form 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
)
\ No newline at end of file
app/applicationlayer/cms/form/details/serializers.py 0 → 100644
View file @ 12eee603
from app.entities import models
from rest_framework import serializers
from django.forms.models import model_to_dict
class ChangeRequestFormDetailsSerializer(
serializers.ModelSerializer
):
class Meta:
model = models.ChangeRequestFormDetails
fields = '__all__'
read_only_fields = ['created', 'code']
\ No newline at end of file
app/applicationlayer/cms/form/details/table_filters.py 0 → 100644
View file @ 12eee603
from django_filters import rest_framework as filters
from app.entities.models import ChangeRequestFormDetails
class DetailsFilter(filters.FilterSet):
class Meta:
model = ChangeRequestFormDetails
fields = '__all__'
app/applicationlayer/cms/form/details/views.py 0 → 100644
View file @ 12eee603
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.form.details.table_filters import DetailsFilter
from app.applicationlayer.cms.form.details import serializers
from app.applicationlayer.utils import (
CustomPagination, status_message_response
)
class ChangeRequestFormDetailsViewset(viewsets.ModelViewSet):
queryset = models.ChangeRequestFormDetails.objects.all()
serializer_class = serializers.ChangeRequestFormDetailsSerializer
pagination_class = CustomPagination
lookup_field = "code"
filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
filterset_class = DetailsFilter
ordering_fields = '__all__'
search_fields = (
'code', 'form_code'
)
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 Form 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/form/header/serializers.py 0 → 100644
View file @ 12eee603
from app.entities import models
from rest_framework import serializers
from django.forms.models import model_to_dict
from django.db.models import Q
from app.applicationlayer.cms.form.approver.serializers import ChangeRequestFormApproversSerializer
from app.applicationlayer.cms.form.stakeholder.serializers import ChangeRequestFormStakeHoldersSerializer
from app.applicationlayer.cms.form.details.serializers import ChangeRequestFormDetailsSerializer
from app.applicationlayer.cms.form.attachment.serializers import ChangeRequestFormAttachmentsSerializer
class ChangeRequestFormHeaderSerializer(
serializers.ModelSerializer
):
frm_approvers = ChangeRequestFormApproversSerializer(
many=True, read_only=True)
frm_stakes = ChangeRequestFormStakeHoldersSerializer(
many=True, read_only=True)
frm_attachments = ChangeRequestFormAttachmentsSerializer(
many=True, read_only=True)
frm_details = ChangeRequestFormDetailsSerializer(
many=True, read_only=True)
def to_representation(self, instance):
ret = super().to_representation(instance)
try:
user = self.context['request'].user
id_number = user.code
current_level = models.ChangeRequestFormApprovers.objects.filter(
Q(form_code=ret['form_code']) &
(Q(action='') | Q(action=None))
).order_by('level')
if current_level[0].user.code == id_number:
if instance.status.lower() == 'rejected':
approver = 'No'
elif instance.status.lower() == 'cancelled':
approver = 'No'
elif instance.status.lower() == 'closed':
approver = 'No'
else:
approver = 'Yes'
else:
approver = 'No'
ret['action'] = approver
requested_to_company = {
"id": instance.requested_to_company.id,
"name": instance.requested_to_company.name,
"contact": instance.requested_to_company.contact_details,
"code": instance.requested_to_company.code
}
requested_to_department = {
"id": instance.requested_to_department.id,
"name": instance.requested_to_department.name,
"code": instance.requested_to_department.code
}
requested_to_user = {
"id": instance.requested_to_user.id,
"name": instance.requested_to_user.name,
"username": instance.requested_to_user.username,
"code": instance.requested_to_user.code,
"email": instance.requested_to_user.email,
"contact_no": instance.requested_to_user.contact_no
}
requested_by_user = {
"id": instance.requested_by_user.id,
"name": instance.requested_by_user.name,
"username": instance.requested_by_user.username,
"code": instance.requested_by_user.code,
"email": instance.requested_by_user.email,
"contact_no": instance.requested_by_user.contact_no
}
requested_by_department = {
"id": instance.requested_by_department.id,
"name": instance.requested_by_department.name,
"code": instance.requested_by_department.code
}
ret['requested_to_company'] = requested_to_company
ret['requested_to_department'] = requested_to_department
ret['requested_to_user'] = requested_to_user
ret['requested_by_user'] = requested_by_user
ret['requested_by_department'] = requested_by_department
return ret
except Exception as e:
ret['action'] = "None"
ret['requested_to_company'] = "None"
ret['requested_to_department'] = "None"
ret['requested_to_user'] = "None"
ret['requested_by_user'] ="None"
ret['requested_by_department'] = "None"
return ret
class Meta:
model = models.ChangeRequestFormHeader
# fields = '__all__'
fields = ('form_code', 'requested_to_template_name', 'requested_to_objective',
'requested_to_target_date', 'requested_to_priority',
'description', 'created', 'cancel_date', 'status',
'company_desc', 'department_desc', 'requested_desc',
'requested_to_template_id', 'requested_to_company',
'requested_to_department', 'requested_to_user',
'requested_by_user', 'requested_by_department',
'template_no', 'frm_approvers', 'frm_stakes',
'frm_attachments', 'frm_details')
read_only_fields = ['created', 'form_code']
class ChangeRequestFormHeaderSerializerList(
serializers.ModelSerializer
):
def to_representation(self, instance):
ret = super().to_representation(instance)
try:
user = self.context['request'].user
id_number = user.code
current_level = models.ChangeRequestFormApprovers.objects.filter(
Q(form_code=ret['form_code']) &
(Q(action='') | Q(action=None))
).order_by('level')
if current_level[0].user.code == id_number:
if instance.status.lower() == 'rejected':
approver = 'No'
elif instance.status.lower() == 'cancelled':
approver = 'No'
elif instance.status.lower() == 'closed':
approver = 'No'
else:
approver = 'Yes'
else:
approver = 'No'
ret['action'] = approver
ret['company'] = instance.requested_to_company.name
ret['department'] = instance.requested_to_department.name
ret['requested_by'] = instance.requested_by_user.name
return ret
except Exception as e:
ret['action'] = "No"
ret['company'] = "None"
ret['department'] = "None"
ret['requested_by'] = "None"
return ret
class Meta:
model = models.ChangeRequestFormHeader
fields = '__all__'
read_only_fields = ['created', 'form_code']
\ No newline at end of file
app/applicationlayer/cms/form/header/table_filters.py 0 → 100644
View file @ 12eee603
from django_filters import rest_framework as filters
from app.entities.models import ChangeRequestFormHeader
class HeaderFilterSet(filters.FilterSet):
class Meta:
model = ChangeRequestFormHeader
fields = '__all__'
app/applicationlayer/cms/form/header/views.py 0 → 100644
View file @ 12eee603
from django.shortcuts import render
from rest_framework import viewsets
from rest_framework.views import APIView
from app.entities import models
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, status_message_response
from app.businesslayer.changerequest import change_request
from app.applicationlayer.cms.utils_cr import (number_generator,
send_mail_requestor,
next_approver_email,
crhistory_save,
send_mail_vendor,
get_max_batchno,
generate_template_id,
crhistory_create_save)
from app.entities import enums
from django.forms.models import model_to_dict
import json
from django.shortcuts import get_object_or_404
from django.db.models import Min
from app.applicationlayer.utils import (CustomPagination,
status_message_response)
from rest_framework.exceptions import ParseError
from app.businesslayer.changerequest.change_request import (
form_add_edit_delete
)
from app.applicationlayer.cms.form.approver.serializers import ChangeRequestFormApproversSerializer
from app.applicationlayer.cms.form.stakeholder.serializers import ChangeRequestFormStakeHoldersSerializer
from app.applicationlayer.cms.form.details.serializers import ChangeRequestFormDetailsSerializer
from app.applicationlayer.cms.form.attachment.serializers import ChangeRequestFormAttachmentsSerializer
from app.applicationlayer.cms.form.header.serializers import (
ChangeRequestFormHeaderSerializer,
ChangeRequestFormHeaderSerializerList)
from app.applicationlayer.cms.form.header.table_filters import HeaderFilterSet
from rest_framework.filters import SearchFilter, OrderingFilter
from django_filters import rest_framework as filters
from django_filters.rest_framework import DjangoFilterBackend
APPROVER_MESSAGE = settings.APPROVER_MESSAGE
REQUESTOR_MESSAGE = settings.REQUESTOR_MESSAGE
REQUESTOR_REJECT_MESSAGE = settings.REQUESTOR_REJECT_MESSAGE
VENDOR_ACKNOWLEDGE_MESSAGE = settings.VENDOR_ACKNOWLEDGE_MESSAGE
REQUESTOR_ACKNOWLEDGE_MESSAGE = settings.REQUESTOR_ACKNOWLEDGE_MESSAGE
REQUESTOR_COMPLETION_MESSAGE = settings.REQUESTOR_COMPLETION_MESSAGE
VENDOR_ACCEPTANCE_MESSAGE = settings.VENDOR_ACCEPTANCE_MESSAGE
VENDOR_REJECT_MESSAGE = settings.VENDOR_REJECT_MESSAGE
class ChangeRequestFormsViewset(viewsets.ModelViewSet):
queryset = models.ChangeRequestFormHeader.objects.all()
serializer_class = ChangeRequestFormHeaderSerializer
pagination_class = CustomPagination
lookup_field = 'form_code'
filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
filterset_class = HeaderFilterSet
ordering_fields = '__all__'
search_fields = (
"form_code", "requested_to_template_id", "requested_by_user__name",
"requested_by_user__code", "requested_by_department__name",
"requested_to_company__name", "requested_to_department__name"
"requested_to_user__name", "requested_to_template_name"
"requested_to_objective", "requested_to_priority", "description"
)
def list(self, request, *args, **kwargs):
self.serializer_class = ChangeRequestFormHeaderSerializerList
id_number = self.request.user.code
self.queryset = change_request.list_by_user(id_number)
self.queryset = change_request.filter_base(
self.queryset,
request.query_params.get('company_requested_to'),
request.query_params.get('department_requested_to'),
request.query_params.get('date_modified_from'),
request.query_params.get('date_modified_to'),
request.query_params.get('date_required_from'),
request.query_params.get('date_required_to'),
request.query_params.get('form_type'),
)
if self.request.query_params.get('search'):
search_key = self.request.query_params.get('search')
self.queryset = self.queryset.filter(
Q(requested_to_template_name__icontains=search_key.lower()) |
Q(requested_to_template_id__icontains=search_key.lower())
)
self.queryset = self.queryset.order_by('-created')
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 Change Request Form 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_view(self, request):
id_number = self.request.user.code
self.queryset = change_request.list_by_user(id_number)
self.queryset = change_request.filter_base(
self.queryset,
request.query_params.get('company_requested_to'),
request.query_params.get('department_requested_to'),
request.query_params.get('date_modified_from'),
request.query_params.get('date_modified_to'),
request.query_params.get('date_required_from'),
request.query_params.get('date_required_to'),
request.query_params.get('form_type'),
)
pending = self.queryset.filter(
status__iexact='Pending'
).count()
approved = self.queryset.filter(
status__iexact='Approved'
).count()
rejected = self.queryset.filter(
status__iexact='Rejected'
).count()
cancelled = self.queryset.filter(
status__iexact='Cancelled'
).count()
completed = self.queryset.filter(
status__iexact='Closed' #Completed
).count()
high = self.queryset.filter(
requested_to_priority='High'
).count()
normal = self.queryset.filter(
requested_to_priority='Normal'
).count()
awaiting_filtered = change_request.filter_awaiting(self.queryset, id_number)
# awaiting = awaiting_filtered.count()
awaiting = 0
for awaits in awaiting_filtered:
if awaits.status.lower() == 'rejected':
print("rejected")
elif awaits.status.lower() == 'closed':
print("closed")
elif awaits.status.lower() == 'cancelled':
print("cancelled")
else:
awaiting = awaiting + 1
overdue_filtered = change_request.filter_overdue(self.queryset)
overdue = overdue_filtered.count()
message = {
'account_no': id_number,
'pending': pending,
'approved': approved,
'rejected': rejected,
'cancelled': cancelled,
'completed': completed,
'high': high,
'normal': normal,
'awaiting': awaiting,
'overdue': overdue,
'code': 200,
'status': 'success',
'message': 'Dashboard Summary'
}
return Response(message, status=status.HTTP_200_OK)
@action(detail=False,
methods=['get'],
url_path='status',
name="Dashboard Summary Status")
def list_by_status_view(self, request):
self.serializer_class = ChangeRequestFormHeaderSerializerList
id_number = self.request.user.code
self.queryset = change_request.list_by_user(id_number)
self.queryset = change_request.filter_status(
self.queryset,
request.query_params.get('status')
)
self.queryset = change_request.filter_base(
self.queryset,
request.query_params.get('company_requested_to'),
request.query_params.get('department_requested_to'),
request.query_params.get('date_modified_from'),
request.query_params.get('date_modified_to'),
request.query_params.get('date_required_from'),
request.query_params.get('date_required_to'),
request.query_params.get('form_type'),
)
self.queryset = self.queryset.order_by('-created')
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 Change Request Form by status 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='overdue',
name="Dashboard Summary Overdue")
def list_by_overdue_view(self, request):
self.serializer_class = ChangeRequestFormHeaderSerializerList
id_number = self.request.user.code
self.queryset = change_request.list_by_user(id_number)
self.queryset = change_request.filter_overdue(self.queryset)
self.queryset = change_request.filter_base(
self.queryset,
request.query_params.get('company_requested_to'),
request.query_params.get('department_requested_to'),
request.query_params.get('date_modified_from'),
request.query_params.get('date_modified_to'),
request.query_params.get('date_required_from'),
request.query_params.get('date_required_to'),
request.query_params.get('form_type'),
)
self.queryset = self.queryset.order_by('-created')
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 Change Request Form by overdue 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='awaiting',
name="Dashboard Summary Awaiting")
def list_by_awaiting_view(self, request):
self.serializer_class = ChangeRequestFormHeaderSerializerList
id_number = self.request.user.code
self.queryset = change_request.list_by_user(id_number)
self.queryset = change_request.filter_awaiting(self.queryset, id_number.code)
self.queryset = change_request.filter_base(
self.queryset,
request.query_params.get('company_requested_to'),
request.query_params.get('department_requested_to'),
request.query_params.get('date_modified_from'),
request.query_params.get('date_modified_to'),
request.query_params.get('date_required_from'),
request.query_params.get('date_required_to'),
request.query_params.get('form_type'),
)
self.queryset = self.queryset.filter(
~Q(status='Rejected') |
~Q(status='Closed') |
~Q(status='Cancelled'))
self.queryset = self.queryset.order_by('-created')
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 Change Request Form 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.queryset.filter(
# form_code=str(self.kwargs.get('form_code'))
# ).first()
# serializer = self.get_serializer(instance)
# return Response(serializer.data)
instance = self.get_object()
serializer = self.get_serializer(instance)
return Response(serializer.data)
@action(
methods=['PATCH'], detail=True,
url_path='re_route', url_name='re_route'
)
def re_route(self, request, *args, **kwargs):
# generate batchno history
batchno = get_max_batchno("batch")
# partial update
partial = kwargs.pop('partial', True)
instance = self.get_object()
form_code = kwargs['form_code']
status_update = {"status": 'Pending'}
serializer = self.get_serializer(instance,
data=status_update,
partial=partial)
serializer.is_valid(raise_exception=True)
old_instance = model_to_dict(instance)
self.perform_update(serializer)
form_header = get_object_or_404(models.ChangeRequestFormHeader,
pk=instance.id)
new_instance = model_to_dict(form_header)
# save history in form header
crhistory_save(
batchno,
enums.CREnum.REROUTE.value,
enums.CREnum.UPDATE.value,
enums.CREntitiesEnum.CR_FRM_HEADER.value,
form_code,
old_instance,
new_instance
)
approver_data = []
# get all approvers of form
approvers = models.ChangeRequestFormApprovers.objects.filter(
form_code=form_code)
for approver in approvers:
approver_add = {
'id': approver.id,
'action': None,
'remarks': None,
'date_sent': None,
'action_date': None
}
approver_data.append(approver_add)
change_request.form_add_edit_delete(
approver_data,
models.ChangeRequestFormApprovers,
enums.CREntitiesEnum.CR_FRM_APPROVER.value,
ChangeRequestFormApproversSerializer,
partial,
self,
form_code,
batchno,
enums.CREnum.REROUTE.value
)
min_level = models.ChangeRequestFormApprovers.objects.filter(
form_code=form_code
).aggregate(Min('level'))
min_level = min_level.get('level__min')
next_approver_email(form_code, min_level)
# update next approver details
models.ChangeRequestFormApprovers.objects.filter(
Q(form_code=form_code) & Q(level=int(min_level))
).update(
date_sent=datetime.now()
)
message = status_message_response(
200, 'success',
'Change request form successfully re routed',
serializer.data
)
return Response(message, status=status.HTTP_200_OK)
@action(
methods=['PATCH'], detail=True,
url_path='re_submit', url_name='re_submit'
)
def re_submit(self, request, *args, **kwargs):
# generate batchno history
batchno = get_max_batchno("batch")
# partial update
partial = kwargs.pop('partial', True)
instance = self.get_object()
form_code = kwargs['form_code']
# get prefix from template header
frm = models.ChangeRequestFormHeader.objects.get(
form_code=form_code)
tmp_prefix = models.ChangeRequestTemplateHeader.objects.get(
template_no=frm.template_no.template_no
)
data_update = {
"status": 'Draft',
"created": datetime.now(),
"requested_to_template_id": tmp_prefix.requested_to_template_id
}
serializer = self.get_serializer(instance,
data=data_update,
partial=partial)
serializer.is_valid(raise_exception=True)
old_instance = model_to_dict(instance)
self.perform_update(serializer)
form_header = get_object_or_404(models.ChangeRequestFormHeader,
pk=instance.id)
new_instance = model_to_dict(form_header)
# save history in form header
crhistory_save(
batchno,
enums.CREnum.RESUBMIT.value,
enums.CREnum.UPDATE.value,
enums.CREntitiesEnum.CR_FRM_HEADER.value,
form_code,
old_instance,
new_instance
)
approver_data = []
# get all approvers of form
approvers = models.ChangeRequestFormApprovers.objects.filter(
form_code=form_code)
for approver in approvers:
approver_add = {
'id': approver.id,
'action': None,
'remarks': None,
'date_sent': None,
'action_date': None,
'created': datetime.now()
}
approver_data.append(approver_add)
change_request.form_add_edit_delete(
approver_data,
models.ChangeRequestFormApprovers,
enums.CREntitiesEnum.CR_FRM_APPROVER.value,
ChangeRequestFormApproversSerializer,
partial,
self,
form_code,
batchno,
enums.CREnum.RESUBMIT.value
)
message = status_message_response(
200, 'success',
'Change request form successfully re submitted',
serializer.data
)
return Response(message, status=status.HTTP_200_OK)
# actions
@action(
methods=['PATCH'], detail=False,
url_path='actions', url_name='actions'
)
def actions(self, request, *args, **kwargs):
# get request data
id = request.data['id']
# current_user = request.data['user']
current_user = self.request.user.code
form_code = request.data['form_code']
delegation = request.data['delegation']
action = request.data['action']
level = request.data['level']
next_level = int(request.data['level']) + 1
remarks = request.data['remarks']
# generate batchno history
batchno = get_max_batchno("batch")
action_data = {
'id': int(request.data['id']),
'action': action,
'remarks': remarks,
'action_date': datetime.now()
}
approver_instance = models.ChangeRequestFormApprovers.objects.get(
pk=id
)
serializer = ChangeRequestFormApproversSerializer(
approver_instance,
data=action_data,
partial=True)
serializer.is_valid(raise_exception=True)
old_instance = model_to_dict(approver_instance)
self.perform_update(serializer)
new_instance = serializer.data
crhistory_save(
batchno,
enums.CREnum.ACTION.value,
enums.CREnum.UPDATE.value,
enums.CREntitiesEnum.CR_FRM_APPROVER.value,
form_code,
old_instance,
new_instance
)
if action.lower() == 'approved':
# NOTIF MSG FOR REQUESTOR
requestor_notification_msg = REQUESTOR_MESSAGE.split(';')[0]
# NOTIF MSG FOR NEXT APPROVER
notification_msg = APPROVER_MESSAGE.split(';')[0]
# SEND EMAIL AND NOTIF TO REQUESTOR
send_mail_requestor(
current_user, form_code, delegation,
requestor_notification_msg, action,
remarks, level
)
next_approver_email(form_code, next_level)
# update next approver details
models.ChangeRequestFormApprovers.objects.filter(
Q(form_code=form_code) & Q(level=int(next_level))
).update(
date_sent=datetime.now()
)
the_next_vendor = models.ChangeRequestFormApprovers.objects.filter(
form_code=form_code, level=int(next_level),
delegation='Vendor/Implementor'
).first()
if the_next_vendor:
the_last_vendor = models.ChangeRequestFormApprovers.objects.filter(
form_code=form_code, delegation='Vendor/Implementor'
).order_by('level').last()
if the_next_vendor == the_last_vendor:
models.ChangeRequestFormHeader.objects.filter(
form_code=form_code
).update(status='Approved')
elif action.lower() == 'rejected':
# send email to vendor
if delegation.lower() == 'requestor':
notification_msg = VENDOR_REJECT_MESSAGE.split(';')[0]
send_mail_vendor(
current_user, form_code, delegation,
notification_msg, action,
remarks, level
)
else:
# EMAIL CODE FOR REQUESTOR
requestor_notification_msg = REQUESTOR_REJECT_MESSAGE.split(';')[0]
# SEND EMAIL AND NOTIF TO REQUESTOR
send_mail_requestor(
current_user, form_code, delegation,
requestor_notification_msg, action,
remarks, level
)
models.ChangeRequestFormHeader.objects.filter(
form_code=form_code
).update(status='Rejected')
elif action.lower() == 'completed':
# EMAIL CODE FOR REQUESTOR
requestor_notification_msg = REQUESTOR_COMPLETION_MESSAGE.split(';')[0]
send_mail_requestor(
current_user, form_code, delegation,
requestor_notification_msg, action,
remarks, level
)
models.ChangeRequestFormApprovers.objects.filter(
Q(level=int(next_level))
).update(
date_sent=datetime.now()
)
models.ChangeRequestFormHeader.objects.filter(
form_code=form_code
).update(status='Completed')
elif action.lower() == 'acknowledged':
# EMAIL CODE FOR REQUESTOR
requestor_notification_msg = REQUESTOR_ACKNOWLEDGE_MESSAGE.split(';')[0]
send_mail_requestor(
current_user, form_code, delegation,
requestor_notification_msg, action,
remarks, level
)
models.ChangeRequestFormHeader.objects.filter(
form_code=form_code
).update(status='Acknowledged')
elif action.lower() == 'accepted':
# EMAIL CODE FOR VENDOR
requestor_notification_msg = VENDOR_ACCEPTANCE_MESSAGE.split(';')[0]
send_mail_vendor(
current_user, form_code, delegation,
requestor_notification_msg, action,
remarks, level
)
models.ChangeRequestFormHeader.objects.filter(
form_code=form_code
).update(status='Closed')
elif action.lower() == 'cancelled':
# changed form status to cancelled
models.ChangeRequestFormHeader.objects.filter(
form_code=form_code).update(status='Cancelled')
message = status_message_response(
200, 'success',
'Action performed',
serializer.data
)
return Response(message, status=status.HTTP_200_OK)
@transaction.atomic
@action(
methods=['PATCH'], detail=True,
url_path='save', url_name='save'
)
def save(self, request, *args, **kwargs):
partial = kwargs.pop('partial', True)
instance = self.get_object()
form_code = kwargs['form_code']
form_data = request.data
# generate batchno history
batchno = get_max_batchno("batch")
data_update = {
"status": 'Draft'
}
data = {**form_data, **data_update}
# update form header
serializer = self.get_serializer(instance,
data=data,
partial=partial)
serializer.is_valid(raise_exception=True)
old_instance = model_to_dict(instance)
self.perform_update(serializer)
new_instance = serializer.data
print(serializer.errors)
# save history in form header
crhistory_save(
batchno,
enums.CREnum.SAVE.value,
enums.CREnum.UPDATE.value,
enums.CREntitiesEnum.CR_FRM_HEADER.value,
form_code,
old_instance,
new_instance
)
change_request.form_add_edit_delete(
form_data['frm_approvers'],
models.ChangeRequestFormApprovers,
enums.CREntitiesEnum.CR_FRM_APPROVER.value,
ChangeRequestFormApproversSerializer,
partial,
self,
form_code,
batchno,
enums.CREnum.SAVE.value
)
change_request.form_add_edit_delete(
form_data['frm_stakes'],
models.ChangeRequestFormStakeHolders,
enums.CREntitiesEnum.CR_FRM_STAKE.value,
ChangeRequestFormStakeHoldersSerializer,
partial,
self,
form_code,
batchno,
enums.CREnum.SAVE.value
)
change_request.form_add_edit_delete(
form_data['frm_attachments'],
models.ChangeRequestFormAttachments,
enums.CREntitiesEnum.CR_FRM_ATTACHMENT.value,
ChangeRequestFormAttachmentsSerializer,
partial,
self,
form_code,
batchno,
enums.CREnum.SAVE.value
)
change_request.form_add_edit_delete(
form_data['frm_details'],
models.ChangeRequestFormDetails,
enums.CREntitiesEnum.CR_FRM_DETAIL.value,
ChangeRequestFormDetailsSerializer,
partial,
self,
form_code,
batchno,
enums.CREnum.SAVE.value
)
serializer = self.get_serializer(instance)
message = status_message_response(
200, 'success',
'Change Request successfully saved',
serializer.data
)
return Response(message, status=status.HTTP_200_OK)
@transaction.atomic
@action(
methods=['PATCH'], detail=True,
url_path='submit', url_name='submit'
)
def submit(self, request, *args, **kwargs):
partial = kwargs.pop('partial', True)
instance = self.get_object()
form_code = kwargs['form_code']
form_data = request.data
# generate batchno history
batchno = get_max_batchno("batch")
# generate requested template id
requested_to_template_id = generate_template_id(
form_data['requested_to_template_id'],
form_code,
form_data['template_no'])
data_update = {
"status": 'Pending',
"created": datetime.now(),
"requested_to_template_id": requested_to_template_id
}
data = {**form_data, **data_update}
# update form header
serializer = self.get_serializer(instance,
data=data,
partial=partial)
serializer.is_valid(raise_exception=True)
old_instance = model_to_dict(instance)
self.perform_update(serializer)
form_header = get_object_or_404(models.ChangeRequestFormHeader,
pk=instance.id)
new_instance = model_to_dict(form_header)
print(serializer.errors)
# save history in form header
crhistory_create_save(
batchno,
enums.CREnum.SUBMIT.value,
enums.CREnum.UPDATE.value,
enums.CREntitiesEnum.CR_FRM_HEADER.value,
form_code,
old_instance,
new_instance,
requested_to_template_id,
form_data['template_no'])
change_request.form_add_edit_delete(
form_data['frm_approvers'],
models.ChangeRequestFormApprovers,
enums.CREntitiesEnum.CR_FRM_APPROVER.value,
ChangeRequestFormApproversSerializer,
partial,
self,
form_code,
batchno,
enums.CREnum.SUBMIT.value
)
change_request.form_add_edit_delete(
form_data['frm_stakes'],
models.ChangeRequestFormStakeHolders,
enums.CREntitiesEnum.CR_FRM_STAKE.value,
ChangeRequestFormStakeHoldersSerializer,
partial,
self,
form_code,
batchno,
enums.CREnum.SUBMIT.value
)
change_request.form_add_edit_delete(
form_data['frm_attachments'],
models.ChangeRequestFormAttachments,
enums.CREntitiesEnum.CR_FRM_ATTACHMENT.value,
ChangeRequestFormAttachmentsSerializer,
partial,
self,
form_code,
batchno,
enums.CREnum.SUBMIT.value
)
change_request.form_add_edit_delete(
form_data['frm_details'],
models.ChangeRequestFormDetails,
enums.CREntitiesEnum.CR_FRM_DETAIL.value,
ChangeRequestFormDetailsSerializer,
partial,
self,
form_code,
batchno,
enums.CREnum.SUBMIT.value
)
serializer = self.get_serializer(instance)
message = status_message_response(
200, 'success',
'Change Request successfully submitted',
serializer.data
)
return Response(message, status=status.HTTP_200_OK)
class ChangeRequestFormPost(APIView):
@transaction.atomic()
def post(self, request):
form_header = request.data
try:
data_list_approver = []
data_list_stake = []
data_list_attach = []
data_list_detail = []
form_header_data = {
'requested_to_template_name': form_header['requested_to_template_name'],
'requested_to_template_id': form_header['requested_to_template_id'],
'requested_to_objective': form_header['requested_to_objective'],
'requested_to_target_date': form_header['requested_to_target_date'],
'requested_to_priority': form_header['requested_to_priority'],
'description': form_header['description'],
'status': form_header['status'],
'company_desc': form_header['company_desc'],
'department_desc': form_header['department_desc'],
'requested_desc': form_header['requested_desc'],
'requested_by_department': form_header['requested_by_department'],
'requested_by_user': form_header['requested_by_user'],
'requested_to_company': form_header['requested_to_company'],
'requested_to_department': form_header['requested_to_department'],
'requested_to_user': form_header['requested_to_user'],
'template_no': form_header['template_no']
}
sp1 = transaction.savepoint() # nothing will save to db
serializer = ChangeRequestFormHeaderSerializer(
data=form_header_data)
if serializer.is_valid(raise_exception=True):
serializer.save()
frm_id = serializer.data['form_code']
# create template approvers
frm_approvers = form_header['frm_approvers']
counter = 0
for frm_approver in frm_approvers:
frm_approver['form_code'] = frm_id
counter = counter + 1
data_list_approver.append(frm_approver)
#append vendor and requestor in routing table
counter = counter + 1
vendor_data = {
'level': counter,
'delegation': 'Vendor/Implementor',
'user': form_header['requested_to_user'],
'form_code': frm_id
}
data_list_approver.append(vendor_data)
counter = counter + 1
requestor_data = {
'level': counter,
'delegation': 'Requestor',
'user': form_header['requested_by_user'],
'form_code': frm_id
}
data_list_approver.append(requestor_data)
serializerApprover = ChangeRequestFormApproversSerializer(
data=data_list_approver, many=True)
if serializerApprover.is_valid(raise_exception=True):
serializerApprover.save()
# create template stakes
if form_header['frm_stakes']:
frm_stakes = form_header['frm_stakes']
for frm_stake in frm_stakes:
frm_stake['form_code'] = frm_id
data_list_stake.append(frm_stake)
serializerStake = ChangeRequestFormStakeHoldersSerializer(
data=data_list_stake, many=True)
if serializerStake.is_valid(raise_exception=True):
serializerStake.save()
# create template attachments
if form_header['frm_attachments']:
frm_attachments = form_header['frm_attachments']
for frm_attachment in frm_attachments:
frm_attachment['form_code'] = frm_id
data_list_attach.append(frm_attachment)
serializerAttach = ChangeRequestFormAttachmentsSerializer(
data=data_list_attach, many=True)
if serializerAttach.is_valid(raise_exception=True):
serializerAttach.save()
# create template details
if form_header['frm_details']:
frm_details = form_header['frm_details']
for frm_detail in frm_details:
frm_detail['form_code'] = frm_id
data_list_detail.append(frm_detail)
serializerDetail = ChangeRequestFormDetailsSerializer(
data=data_list_detail, many=True)
if serializerDetail.is_valid(raise_exception=True):
serializerDetail.save()
# if status is pending send initial email and
# generate template id
if serializer.data['status'].lower() == 'pending':
template_no = serializer.data['template_no']
CR_Prefix = serializer.data['requested_to_template_id']
# generate batchno history
batchno = get_max_batchno("batch")
# generate requested template id
requested_to_template_id = generate_template_id(
CR_Prefix, frm_id, template_no
)
#save to history for request template id tracking
crhistory_create_save(
batchno,
enums.CREnum.CREATE.value,
enums.CREnum.ADD.value,
enums.CREntitiesEnum.CR_FRM_HEADER.value,
frm_id,
'',
serializer.data,
requested_to_template_id,
template_no)
min_level = models.ChangeRequestFormApprovers.objects.filter(
form_code=frm_id
).aggregate(Min('level'))
min_level = min_level.get('level__min')
next_approver_email(frm_id, min_level)
message = {
'code': 201,
'status': 'success',
'message': 'Form Details successfully saved!',
'results': serializer.data
}
return Response(message, status=status.HTTP_201_CREATED)
except ValidationError as e:
transaction.savepoint_rollback(sp1)
message = {
'code': 400,
'status': 'failed',
'message': str(e),
}
return Response(message, status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
transaction.savepoint_rollback(sp1)
message = {
'code': 500,
'status': 'failed',
'message': 'Request was not able to process' + str(e),
}
return Response(message,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
app/applicationlayer/cms/form/stakeholder/serializers.py 0 → 100644
View file @ 12eee603
from app.entities import models
from rest_framework import serializers
from django.forms.models import model_to_dict
class ChangeRequestFormStakeHoldersSerializer(
serializers.ModelSerializer
):
def to_representation(self, instance):
try:
ret = super().to_representation(instance)
user_object = {
"id": instance.user.id,
"name": instance.user.name,
"username": instance.user.username,
"code": instance.user.code,
"email": instance.user.email,
"contact_no": instance.user.contact_no
}
ret['company'] = model_to_dict(instance.user.department.company)
ret['department'] = model_to_dict(instance.user.department)
ret['user'] = user_object
return ret
except Exception as e:
ret['company'] = "none"
ret['department'] = "none"
ret['name'] = "none"
return ret
class Meta:
model = models.ChangeRequestFormStakeHolders
fields = '__all__'
read_only_fields = ['created', 'code']
\ No newline at end of file
app/applicationlayer/cms/form/stakeholder/table_filters.py 0 → 100644
View file @ 12eee603
from django_filters import rest_framework as filters
from app.entities.models import ChangeRequestFormStakeHolders
class StakeHolderFilter(filters.FilterSet):
class Meta:
model = ChangeRequestFormStakeHolders
fields = '__all__'
app/applicationlayer/cms/form/stakeholder/views.py 0 → 100644
View file @ 12eee603
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.form.stakeholder.table_filters import StakeHolderFilter
from app.applicationlayer.cms.form.stakeholder import serializers
from app.applicationlayer.utils import (
CustomPagination, status_message_response
)
class ChangeRequestFormStakeHoldersViewset(viewsets.ModelViewSet):
queryset = models.ChangeRequestFormStakeHolders.objects.all()
serializer_class = serializers.ChangeRequestFormStakeHoldersSerializer
pagination_class = CustomPagination
lookup_field = "code"
filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
filterset_class = StakeHolderFilter
ordering_fields = '__all__'
search_fields = (
'name', 'code',
'department__company__name',
'department__name',
'email', 'contact_no'
)
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 Templates Stakeholders 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/form/views.py
View file @ 12eee603
......@@ -554,13 +554,21 @@ class ChangeRequestFormsViewset(meviewsets.ModelViewSet):
date_sent=datetime.now()
)
the_last_vendor = models.ChangeRequestFormApprovers.objects.filter(
the_next_vendor = models.ChangeRequestFormApprovers.objects.filter(
form_code=form_code, level=str(next_level),
delegation='Vendor/Implementor'
).first()
print(the_last_vendor) #comment
if the_next_vendor:
the_last_vendor = models.ChangeRequestFormApprovers.objects.filter(
form_code=form_code, delegation='Vendor/Implementor'
).order_by('level').last()
if the_next_vendor == the_last_vendor:
models.ChangeRequestFormHeader.objects.filter(
form_code=form_code
).update(status='Approved')
elif action.lower() == 'rejected':
# send email to vendor
......@@ -583,6 +591,10 @@ class ChangeRequestFormsViewset(meviewsets.ModelViewSet):
requestor_notification_msg, action,
remarks, level
)
models.ChangeRequestFormHeader.objects.filter(
form_code=form_code
).update(status='Rejected')
elif action.lower() == 'completed':
......@@ -601,6 +613,10 @@ class ChangeRequestFormsViewset(meviewsets.ModelViewSet):
date_sent=datetime.now()
)
models.ChangeRequestFormHeader.objects.filter(
form_code=form_code
).update(status='Completed')
elif action.lower() == 'acknowledged':
# EMAIL CODE FOR REQUESTOR
......@@ -612,6 +628,10 @@ class ChangeRequestFormsViewset(meviewsets.ModelViewSet):
remarks, level
)
models.ChangeRequestFormHeader.objects.filter(
form_code=form_code
).update(status='Acknowledged')
elif action.lower() == 'accepted':
# EMAIL CODE FOR VENDOR
......@@ -623,6 +643,10 @@ class ChangeRequestFormsViewset(meviewsets.ModelViewSet):
remarks, level
)
models.ChangeRequestFormHeader.objects.filter(
form_code=form_code
).update(status='Closed')
elif action.lower() == 'cancelled':
# changed form status to cancelled
......@@ -630,7 +654,7 @@ class ChangeRequestFormsViewset(meviewsets.ModelViewSet):
models.ChangeRequestFormHeader.objects.filter(
form_code=form_code).update(status='Cancelled')
message = status_message_response(
200, 'success',
'Action performed',
......
app/applicationlayer/cms/template/attachment/serializers.py
View file @ 12eee603
......@@ -6,6 +6,7 @@ from django.forms.models import model_to_dict
class ChangeRequestTemplateAttachmentsSerializer(
serializers.ModelSerializer
):
def to_representation(self, instance):
try:
ret = super().to_representation(instance)
......@@ -18,7 +19,7 @@ class ChangeRequestTemplateAttachmentsSerializer(
"contact_no": instance.uploaded_by.contact_no
}
ret['uploaded_by'] = user_object
ret['file_upload'] = self.context['request'].build_absolute_uri(instance.file_upload.url.url)
return ret
except Exception as e:
ret['uploaded_by'] = "none"
......@@ -26,5 +27,17 @@ class ChangeRequestTemplateAttachmentsSerializer(
class Meta:
model = models.ChangeRequestTemplateAttachments
# fields = (
# "id",
# "attachment_type",
# "attachment_name",
# "file_name",
# "description",
# "created",
# "code",
# "uploaded_by",
# "file_upload",
# "template_no"
# )
fields = '__all__'
read_only_fields = ['created', 'code']
read_only_fields = ['created', 'code']
\ No newline at end of file
app/applicationlayer/cms/template/header/serializers.py
View file @ 12eee603
......@@ -11,59 +11,12 @@ from app.applicationlayer.cms.utils_cr import (get_account_details,
from app.applicationlayer.cms.template.approver.serializers import ChangeRequestTemplateApproversSerializer
from app.applicationlayer.cms.template.stakeholder.serializers import ChangeRequestTemplateStakeHoldersSerializer
from app.applicationlayer.cms.template.attachment.serializers import ChangeRequestTemplateAttachmentsSerializer
from app.applicationlayer.cms.template.details.serializers import ChangeRequestTemplateDetailsSerializer
from django.conf import settings
class ChangeRequestTemplateAttachmentsSerializer(
serializers.ModelSerializer
):
def to_representation(self, instance):
try:
ret = super().to_representation(instance)
user_object = {
"id": instance.uploaded_by.id,
"name": instance.uploaded_by.name,
"username": instance.uploaded_by.username,
"code": instance.uploaded_by.code,
"email": instance.uploaded_by.email,
"contact_no": instance.uploaded_by.contact_no
}
ret['uploaded_by'] = user_object
ret['file_upload'] = self.context['request'].build_absolute_uri(instance.file_upload.url.url)
return ret
except Exception as e:
ret['uploaded_by'] = "none"
return ret
class Meta:
model = models.ChangeRequestTemplateAttachments
# fields = (
# "id",
# "attachment_type",
# "attachment_name",
# "file_name",
# "description",
# "created",
# "code",
# "uploaded_by",
# "file_upload",
# "template_no"
# )
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
):
......
app/applicationlayer/cms/urls_cms.py
View file @ 12eee603
......@@ -21,6 +21,15 @@ from app.applicationlayer.cms.template.details import views as details
from app.applicationlayer.cms.template.attachment import views as attachment
# TEMPLATE
# FORM
from app.applicationlayer.cms.form.header import views as headerform
from app.applicationlayer.cms.form.approver import views as approverform
from app.applicationlayer.cms.form.stakeholder import views as stakeholderform
from app.applicationlayer.cms.form.details import views as detailsform
from app.applicationlayer.cms.form.attachment import views as attachmentform
# FORM
router = routers.DefaultRouter()
router.register(r'notifications', NotificationsViewset)
......@@ -31,11 +40,11 @@ router.register(r'template-attachments', attachment.ChangeRequestTemplateAttachm
router.register(r'template-stakeholders', stakeholder.ChangeRequestTemplateStakeholdersViewset)
router.register(r'template-details', details.ChangeRequestTemplateDetailsViewset)
router.register(r'form', crform_views.ChangeRequestFormsViewset)
router.register(r'form-approvers', crform_views.ChangeRequestFormApproversViewset)
router.register(r'form-stakeholders', crform_views.ChangeRequestFormStakeHoldersViewset)
router.register(r'form-attachments', crform_views.ChangeRequestFormAttachmentsViewset)
router.register(r'form-details', crform_views.ChangeRequestFormDetailsViewset)
router.register(r'form', headerform.ChangeRequestFormsViewset)
router.register(r'form-approvers', approverform.ChangeRequestFormApproversViewset)
router.register(r'form-stakeholders', stakeholderform.ChangeRequestFormStakeHoldersViewset)
router.register(r'form-attachments', attachmentform.ChangeRequestFormAttachmentsViewset)
router.register(r'form-details', detailsform.ChangeRequestFormDetailsViewset)
# privilege CMS
router.register(r'allowed-companies', allowed.AllowedCompanyViewSet)
......@@ -50,7 +59,7 @@ router.register(r'departments', ChangeRequestDepartmentViewSet)
urlpatterns = (
path('', include(router.urls)),
path('template-post/', header.ChangeRequestTemplatePost.as_view()),
path('form-post/', crform_views.ChangeRequestFormPost.as_view()),
path('form-post/', headerform.ChangeRequestFormPost.as_view()),
# filter endpoints under Allowed Companies table
path('user-list/', UserList.as_view(), name="User List"),
# filter endpoints under Allowed Companies table
......
app/entities/migrations/0004_auto_20190928_1656.py 0 → 100644
View file @ 12eee603
# Generated by Django 2.2 on 2019-09-28 16:56
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('entities', '0003_changerequesthistory_template_no'),
]
operations = [
migrations.AlterField(
model_name='changerequestformapprovers',
name='level',
field=models.IntegerField(),
),
migrations.AlterField(
model_name='changerequesttemplateapprovers',
name='level',
field=models.IntegerField(default=1),
preserve_default=False,
),
migrations.AlterField(
model_name='changerequesttemplateheader',
name='requested_to_target_date',
field=models.IntegerField(blank=True, null=True),
),
]
app/entities/models.py
View file @ 12eee603
......@@ -400,10 +400,7 @@ class BaseHeader(models.Model):
class BaseApprover(models.Model):
level = models.CharField(
max_length=50,
blank=True,
null=True)
level = models.IntegerField()
user = models.ForeignKey(
User,
......@@ -526,8 +523,7 @@ class ChangeRequestTemplateHeader(BaseHeader):
to_field='code',
related_name='created_by_department')
requested_to_target_date = models.CharField(
max_length=10,
requested_to_target_date = models.IntegerField(
blank=True,
null=True)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment