Skip to content

R
red-ci-cd
Commit e87e33b8 authored by John Red Medrano's avatar John Red Medrano
Browse files
Options

Merge pull request #783 in RMS/api-main-service from core-dev-red-develop to RMSv2 

* commit '1c49bc58':
  {dev bugfix} removed all import that used the deleted files
  {dev bugfix} delete un used codes and folder
parents cde3f61d 1c49bc58
Hide whitespace changes
Inline Side-by-side
Showing with 4 additions and 2155 deletions
app/applicationlayer/authentication/apps.py deleted 100644 → 0
View file @ cde3f61d
from django.apps import AppConfig
class AuthenticationConfig(AppConfig):
name = 'authentication'
app/applicationlayer/authentication/models.py deleted 100644 → 0
View file @ cde3f61d
from django.db import models
# Create your models here.
app/applicationlayer/authentication/views.py deleted 100644 → 0
View file @ cde3f61d
from django.shortcuts import render
# Create your views here.
app/applicationlayer/cms/auto_email/cancel.py
View file @ e87e33b8
from app.entities import models
from app.applicationlayer import paginators
from datetime import datetime
from rest_framework.response import Response
from rest_framework import status, views
......
app/applicationlayer/cms/auto_email/overdue.py
View file @ e87e33b8
from app.entities import models
from app.applicationlayer import paginators
from datetime import datetime
from rest_framework.response import Response
from rest_framework import status, views
......
app/applicationlayer/cms/auto_email/reminder.py
View file @ e87e33b8
from app.entities import models
from app.applicationlayer import paginators
from datetime import datetime
from rest_framework.response import Response
from rest_framework import status, views
......
app/applicationlayer/cms/form/serializers.py deleted 100644 → 0
View file @ cde3f61d
from app.entities import models
from rest_framework import serializers
from django.db.models import Q
from drf_writable_nested import WritableNestedModelSerializer
from app.applicationlayer.utils 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']
class ChangeRequestFormStakeHoldersSerializer(
serializers.ModelSerializer
):
class Meta:
model = models.ChangeRequestFormStakeHolders
fields = '__all__'
read_only_fields = ['created', 'code']
class ChangeRequestFormAttachmentsSerializer(
serializers.ModelSerializer
):
class Meta:
model = models.ChangeRequestFormAttachments
fields = '__all__'
read_only_fields = ['created', 'code']
class ChangeRequestFormDetailsSerializer(
serializers.ModelSerializer
):
class Meta:
model = models.ChangeRequestFormDetails
fields = '__all__'
read_only_fields = ['created', 'code']
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() == 'completed & accepted':
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__'
fields = ('form_code', 'requested_to_template_name', 'requested_to_objective',
'requested_to_target_date', 'requested_to_priority',
'description', 'created', 'cancel_date', 'status',
'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']
# 'company_desc', 'department_desc', 'requested_desc',
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() == 'completed & accepted':
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/views.py deleted 100644 → 0
View file @ cde3f61d
from django.shortcuts import render
from rest_framework import viewsets as meviewsets
from rest_framework.views import APIView
from app.applicationlayer.cms.form 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, 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 app.applicationlayer.utils 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)
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
# Change Request Form Views
class ChangeRequestFormsViewset(meviewsets.ModelViewSet):
serializer_class = serializers.ChangeRequestFormHeaderSerializer
# pagination_class = paginators.SimplePageNumberPagination
pagination_class = CustomPagination
queryset = models.ChangeRequestFormHeader.objects.all()
lookup_field = 'form_code'
def list(self, request, *args, **kwargs):
self.serializer_class = serializers.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')
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 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
)
# return super(ChangeRequestFormsViewset, self).list(request)
@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='Completed & Accepted' #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() == 'completed & accepted':
print("completed & accepted")
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):
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')
self.queryset = QuerySetHelper.Sort(self)
return super(ChangeRequestFormsViewset, self).list(request)
@action(detail=False,
methods=['get'],
url_path='overdue',
name="Dashboard Summary Overdue")
def list_by_overdue_view(self, request):
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')
self.queryset = QuerySetHelper.Sort(self)
return super(ChangeRequestFormsViewset, self).list(request)
@action(detail=False,
methods=['get'],
url_path='awaiting',
name="Dashboard Summary Awaiting")
def list_by_awaiting_view(self, request):
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='Completed & Accepted') |
~Q(status='Cancelled'))
self.queryset = self.queryset.order_by('-created')
self.queryset = QuerySetHelper.Sort(self)
return super(ChangeRequestFormsViewset, self).list(request)
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)
@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,
serializers.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=str(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,
serializers.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 = serializers.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=str(next_level))
).update(
date_sent=datetime.now()
)
the_next_vendor = models.ChangeRequestFormApprovers.objects.filter(
form_code=form_code, level=str(next_level),
delegation__name='Vendor/Implementor'
).first()
if the_next_vendor:
the_last_vendor = models.ChangeRequestFormApprovers.objects.filter(
form_code=form_code, delegation__name='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=str(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='Completed & Accepted')
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")
# update form header
serializer = self.get_serializer(instance,
data=form_data,
partial=partial)
serializer.is_valid(raise_exception=True)
old_instance = model_to_dict(instance)
self.perform_update(serializer)
new_instance = serializer.data
# 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,
serializers.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,
serializers.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,
serializers.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,
serializers.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)
# 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,
serializers.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,
serializers.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,
serializers.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,
serializers.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 ChangeRequestFormApproversViewset(meviewsets.ModelViewSet):
queryset = models.ChangeRequestFormApprovers.objects.all()
serializer_class = serializers.ChangeRequestFormApproversSerializer
pagination_class = paginators.SimplePageNumberPagination
lookup_field = 'code'
def list(self, request, *args, **kwargs):
self.queryset = QuerySetHelper.Sort(self)
return super(ChangeRequestFormApproversViewset, self).list(request)
class ChangeRequestFormAttachmentsViewset(meviewsets.ModelViewSet):
queryset = models.ChangeRequestFormAttachments.objects.all()
serializer_class = serializers.ChangeRequestFormAttachmentsSerializer
pagination_class = paginators.SimplePageNumberPagination
def list(self, request, *args, **kwargs):
self.queryset = QuerySetHelper.Sort(self)
self.queryset = QuerySetHelper.Filter(self)
return super(
ChangeRequestFormAttachmentsViewset, self
).list(request)
class ChangeRequestFormStakeHoldersViewset(meviewsets.ModelViewSet):
queryset = models.ChangeRequestFormStakeHolders.objects.all()
serializer_class = serializers.ChangeRequestFormStakeHoldersSerializer
pagination_class = paginators.SimplePageNumberPagination
def list(self, request, *args, **kwargs):
self.queryset = QuerySetHelper.Sort(self)
self.queryset = QuerySetHelper.Filter(self)
return super(ChangeRequestFormStakeHoldersViewset, self).list(request)
class ChangeRequestFormDetailsViewset(meviewsets.ModelViewSet):
queryset = models.ChangeRequestFormDetails.objects.all()
serializer_class = serializers.ChangeRequestFormDetailsSerializer
pagination_class = paginators.SimplePageNumberPagination
def list(self, request, *args, **kwargs):
self.queryset = QuerySetHelper.Sort(self)
self.queryset = QuerySetHelper.Filter(self)
return super(ChangeRequestFormDetailsViewset, self).list(request)
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'],
'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']
}
# 'company_desc': form_header['company_desc'],
# 'department_desc': form_header['department_desc'],
# 'requested_desc': form_header['requested_desc'],
sp1 = transaction.savepoint() # nothing will save to db
serializer = serializers.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 = serializers.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 = serializers.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 = serializers.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 = serializers.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)
\ No newline at end of file
app/applicationlayer/cms/template/serializers.py deleted 100644 → 0
View file @ cde3f61d
from app.entities import models
from rest_framework import serializers
from django.db.models import Q
from app.applicationlayer.utils 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'] = instance.requested_to_company.name
ret['department'] = instance.requested_to_department.name
ret['point_of_contact'] = instance.requested_to_user.name
ret['created_by'] = instance.created_by_user.name
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']
class ChangeRequestTemplatesSerializerList(
serializers.ModelSerializer
):
def to_representation(self, instance):
ret = super().to_representation(instance)
try:
ret['company'] = instance.requested_to_company.name
ret['department'] = instance.requested_to_department.name
ret['point_of_contact'] = instance.requested_to_user.name
ret['created_by'] = instance.created_by_user.name
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__'
read_only_fields = ['created', 'template_no']
app/applicationlayer/cms/template/views.py deleted 100644 → 0
View file @ cde3f61d
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 rest_framework.response import Response
from rest_framework import status, views
from rest_framework.decorators import action
from django.db.models import Q
from rest_framework.exceptions import ValidationError
from django.db import transaction
from app.applicationlayer.utils import (CustomPagination,
status_message_response)
from app.applicationlayer.cms.utils_cr import (
entity_log_bulk
)
from app.applicationlayer.utils import model_to_dict
from app.entities import enums, models
from django.db.models import Q
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):
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)
class ChangeRequestTemplatesViewset(meviewsets.ModelViewSet):
queryset = models.ChangeRequestTemplateHeader.objects.all()
lookup_field = 'template_no'
serializer_class = serializers.ChangeRequestTemplatesSerializer
pagination_class = CustomPagination
def list(self, request, *args, **kwargs):
self.serializer_class = serializers.ChangeRequestTemplatesSerializerList
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 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(
template_no=str(self.kwargs.get('template_no'))
).first()
serializer = self.get_serializer(instance)
return Response(serializer.data)
@transaction.atomic()
def destroy(self, request, *args, **kwargs):
try:
template_no = self.kwargs['template_no']
enum_approver = enums.LogEntitiesEnum.ChangeRequestTemplateApprovers.value
enum_stake = enums.LogEntitiesEnum.ChangeRequestTemplateStakeHolders.value
enum_attach = enums.LogEntitiesEnum.ChangeRequestTemplateAttachments.value
enum_detail = enums.LogEntitiesEnum.ChangeRequestTemplateDetails.value
enum_header = enums.LogEntitiesEnum.ChangeRequestTemplateHeader.value
approver = models.ChangeRequestTemplateApprovers.objects.filter(
template_no=template_no
)
if approver.count() > 0:
entity_log_bulk(
approver, enum_approver,
models.ChangeRequestTemplateApprovers
)
stake = models.ChangeRequestTemplateStakeHolders.objects.filter(
template_no=template_no
)
if stake.count() > 0:
entity_log_bulk(
stake, enum_stake,
models.ChangeRequestTemplateStakeHolders
)
attachment = models.ChangeRequestTemplateAttachments.objects.filter(
template_no=template_no
)
if attachment.count() > 0:
entity_log_bulk(
attachment, enum_attach,
models.ChangeRequestTemplateAttachments
)
details = models.ChangeRequestTemplateDetails.objects.filter(
template_no=template_no
)
if details.count() > 0:
entity_log_bulk(
details, enum_detail,
models.ChangeRequestTemplateDetails
)
header = models.ChangeRequestTemplateHeader.objects.filter(
template_no=template_no
)
if header.count() > 0:
entity_log_bulk(
header, enum_header,
models.ChangeRequestTemplateHeader
)
return Response({"message": "Deleted"}, status=status.HTTP_200_OK)
except Exception as e:
return Response(e,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
@transaction.atomic
def partial_update(self, request, *args, **kwargs):
partial = kwargs.pop('partial', True)
instance = self.get_object()
template_no = kwargs['template_no']
body_data = request.data
tmp_no_exists = models.ChangeRequestFormHeader.objects.filter(
template_no=template_no)
if not tmp_no_exists:
serializer = self.get_serializer(instance,
data=request.data,
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.ChangeRequestTemplateHeader.value,
old_instance['id'],
old_instance,
new_instance
)
tmp_add_edit_delete(
body_data['tmp_approvers'],
models.ChangeRequestTemplateApprovers,
enums.LogEntitiesEnum.ChangeRequestTemplateApprovers.value,
ChangeRequestTemplateApproversSerializer,
partial,
self,
template_no
)
tmp_add_edit_delete(
body_data['tmp_stakes'],
models.ChangeRequestTemplateStakeHolders,
enums.LogEntitiesEnum.ChangeRequestTemplateStakeHolders.value,
ChangeRequestTemplateStakeHoldersSerializer,
partial,
self,
template_no
)
tmp_add_edit_delete(
body_data['tmp_attachments'],
models.ChangeRequestTemplateAttachments,
enums.LogEntitiesEnum.ChangeRequestTemplateAttachments.value,
serializers.ChangeRequestTemplateAttachmentsSerializer,
partial,
self,
template_no
)
tmp_add_edit_delete(
body_data['tmp_details'],
models.ChangeRequestTemplateDetails,
enums.LogEntitiesEnum.ChangeRequestTemplateDetails.value,
serializers.ChangeRequestTemplateDetailsSerializer,
partial,
self,
template_no
)
serializer = self.get_serializer(instance)
message = status_message_response(
200, 'success',
'Change Request Template successfully updated',
serializer.data
)
return Response(message, status=status.HTTP_200_OK)
return Response(
"Unable to edit due to existing transaction",
status=status.HTTP_400_BAD_REQUEST
)
class ChangeRequestTemplatePost(APIView):
@transaction.atomic()
def post(self, request):
template_header = request.data
try:
data_list_approver = []
data_list_stake = []
data_list_attach = []
data_list_detail = []
template_header_data = {
'requested_to_template_name': template_header['requested_to_template_name'],
'requested_to_template_id': template_header['requested_to_template_id'],
'requested_to_objective': template_header['requested_to_objective'],
'requested_to_target_date': template_header['requested_to_target_date'],
'requested_to_priority': template_header['requested_to_priority'],
'description': template_header['description'],
'created_by_department': template_header['created_by_department'],
'created_by_user': template_header['created_by_user'],
'requested_to_company': template_header['requested_to_company'],
'requested_to_department': template_header['requested_to_department'],
'requested_to_user': template_header['requested_to_user']
}
sp1 = transaction.savepoint() # nothing will save to db
serializer = serializers.ChangeRequestTemplatesSerializer(
data=template_header_data)
if serializer.is_valid(raise_exception=True):
serializer.save()
tmp_id = serializer.data['template_no']
# create template approvers
tmp_approvers = template_header['tmp_approvers']
for tmp_approver in tmp_approvers:
tmp_approver['template_no'] = tmp_id
data_list_approver.append(tmp_approver)
serializerApprover = ChangeRequestTemplateApproversSerializer(
data=data_list_approver, many=True)
if serializerApprover.is_valid(raise_exception=True):
serializerApprover.save()
# create template stakes
if template_header['tmp_stakes']:
tmp_stakes = template_header['tmp_stakes']
for tmp_stake in tmp_stakes:
tmp_stake['template_no'] = tmp_id
data_list_stake.append(tmp_stake)
serializerStake = ChangeRequestTemplateStakeHoldersSerializer(
data=data_list_stake, many=True)
if serializerStake.is_valid(raise_exception=True):
serializerStake.save()
# create template attachments
if template_header['tmp_attachments']:
tmp_attachments = template_header['tmp_attachments']
for tmp_attachment in tmp_attachments:
tmp_attachment['template_no'] = tmp_id
data_list_attach.append(tmp_attachment)
serializerAttach = ChangeRequestTemplateAttachmentsSerializer(
data=data_list_attach, many=True)
if serializerAttach.is_valid(raise_exception=True):
serializerAttach.save()
# create template details
if template_header['tmp_details']:
tmp_details = template_header['tmp_details']
for tmp_detail in tmp_details:
tmp_detail['template_no'] = tmp_id
data_list_detail.append(tmp_detail)
serializerDetail = ChangeRequestTemplateDetailsSerializer(
data=data_list_detail, many=True)
if serializerDetail.is_valid(raise_exception=True):
serializerDetail.save()
message = {
'code': 201,
'status': 'success',
'message': 'Template 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/urls_cms.py
View file @ e87e33b8
......@@ -4,7 +4,6 @@ from django.conf.urls import url
from rest_framework.urlpatterns import format_suffix_patterns
from app.applicationlayer.cms.form import views as crform_views
from app.applicationlayer.cms.allowed_company import views as allowed
# MASTERS Form
......
app/applicationlayer/management/notification/views.py
View file @ e87e33b8
......@@ -5,8 +5,6 @@ import json
from rest_framework import viewsets as meviewsets
from app.applicationlayer.management.notification import serializers
from app.entities import models
from app.applicationlayer import paginators
from datetime import datetime
from rest_framework.response import Response
......
app/applicationlayer/paginators.py deleted 100644 → 0
View file @ cde3f61d
from rest_framework import pagination
from collections import OrderedDict
from rest_framework.response import Response
from django.core.paginator import InvalidPage
from rest_framework.exceptions import NotFound
from django.utils import six
from django.utils.translation import ugettext_lazy as _
class SimplePageNumberPagination(pagination.PageNumberPagination):
page_query_param = 'page'
page_size_query_param = 'page-size'
max_page_size = 1000
invalid_page_message = _('Invalid page.')
def paginate_queryset(self, queryset, request, view=None):
"""
Paginate a queryset if required, either returning a
page object, or `None` if pagination is not configured for this view.
"""
page_size = self.get_page_size(request)
if not page_size:
return None
paginator = self.django_paginator_class(queryset, page_size)
page_number = request.query_params.get(self.page_query_param, 1)
if page_number in self.last_page_strings:
page_number = paginator.num_pages
try:
if len(queryset) < page_size:
page_number = 1
self.page = paginator.page(page_number)
except InvalidPage as exc:
msg = self.invalid_page_message.format(
page_number=page_number, message=six.text_type(exc)
)
raise NotFound(msg)
if paginator.num_pages > 1 and self.template is not None:
# The browsable API should display pagination controls.
self.display_page_controls = True
self.request = request
return list(self.page)
def get_paginated_response(self, data, additional_info=None):
content = [
('count', self.page.paginator.count),
('next', self.get_next_link()),
('previous', self.get_previous_link()),
('results', data),
('page', self.page.number),
('additional_info', additional_info)
]
return Response(OrderedDict(content))
app/applicationlayer/serializers.py deleted 100644 → 0
View file @ cde3f61d
from rest_framework import serializers
from app.entities import models
class DepartmentSerializer(serializers.ModelSerializer):
class Meta:
model = models.Department
fields = ('__all__')
depth = 0
app/businesslayer/changerequest/change_request.py
View file @ e87e33b8
from django.shortcuts import render
from app.entities import models
from app.applicationlayer import paginators
from datetime import datetime
......@@ -31,7 +30,6 @@ from app.applicationlayer.cms.utils_cr import (
from app.applicationlayer.utils import model_to_dict
from app.entities import enums, models
from app.applicationlayer.utils import log_save, CustomPagination
from app.applicationlayer.cms.template import serializers
from django.db.models import Min
from django.conf import settings
......
app/businesslayer/changerequest/change_request_template.py
View file @ e87e33b8
from django.shortcuts import render
from app.entities import models
from app.applicationlayer import paginators
from datetime import datetime
......@@ -18,7 +17,6 @@ from app.applicationlayer.cms.utils_cr import (
from app.applicationlayer.utils import model_to_dict
from app.entities import enums, models
from app.applicationlayer.utils import log_save, CustomPagination
from app.applicationlayer.cms.template import serializers
import itertools
from operator import itemgetter
......
app/entities/enums.py
View file @ e87e33b8
......@@ -2,18 +2,6 @@ from enum import Enum
class ModelSeriesEnum(Enum):
USER = "USR"
# CLIENT = "CLI"
# CONSUMABLEPRODUCTS = "CSP"
# PROJECT = "PRJ"
# SERIALIZEITEM = "ITM"
# SERIALIZEPRODUCT = "SRP"
# SUPPLIER = "SUP"
# WAREHOUSE = "WHL"
# ACQUISITION = 'AQN'
# REQUISITION = 'RQN'
# PURCHASEREQUEST = 'PR'
# STOCKTAKE = 'STK'
# CHECKOUT = 'CHK'
class UserTypeEnum(Enum):
SUPER_USER = "SU"
......@@ -77,22 +65,6 @@ class LogEntitiesEnum(Enum):
ChangeRequestFormAttachments = "ChangeRequestFormAttachments"
ChangeRequestFormDetails = "ChangeRequestFormDetails"
# BRAND = "Brand"
# CATEGORY = "Category"
# CURRENCY = "Currency"
# UNIT_MATERIAL = "Unit Material"
# NEWS = "News"
# PROJECT = "Project"
# PROJECT_LOCATION = "Project Location"
# WAREHOUSE = "Warehouse"
# SUPPLIER = "Supplier"
# CLIENT = "Client"
# PRODUCT = "Product"
# ACQUISITION_ITEM = "Acquisition Item"
# STOCK = "Stock"
# STOCK_ITEM = "Stock Item"
# REQUISITION = "Requisition Header"
'''
*********
CR HISTORY ENUMS
......
config/settings/demo.py deleted 100644 → 0
View file @ cde3f61d
from .base import *
import configparser
DEBUG = False
ALLOWED_HOSTS = ['*']
# CORS_ORIGIN_ALLOW_ALL = True
config = configparser.ConfigParser()
config_file = os.path.join('./', 'env.ini')
config.read(config_file)
CHANNEL_LAYERS = {
'default': {
'BACKEND': 'channels_redis.core.RedisChannelLayer',
'CONFIG': {
"hosts": [('172.17.0.1', 6379)],
# "hosts": [('127.0.0.1', 6379)],
},
},
}
DATABASES = {
'default': {
'ENGINE': config['DEMO']['DATABASE_ENGINE'],
'NAME': config['DEMO']['DATABASE_NAME'],
'USER': config['DEMO']['DATABASE_USER'],
'PASSWORD': config['DEMO']['DATABASE_PASSWORD'],
'HOST': config['DEMO']['DATABASE_HOST'],
'PORT': config['DEMO']['DATABASE_PORT'],
}
}
# ****************
# PROGRAM SETTINGS
# ****************
SESSION_TIMEOUT = config['DEMO']['SESSION_TIMEOUT']
FRONT_END_URL = config['DEMO']['FRONT_END_URL']
AUTH_ACCESSS_TOKEN_TIMEOUT = config['DEMO']['AUTH_ACCESSS_TOKEN_TIMEOUT']
USER_DEFAULT_PASSWORD = config['DEMO']['USER_DEFAULT_PASSWORD']
REALTIMESERVER_IP = config['DEMO']['REALTIMESERVER_IP']
# Notification Messages
APPROVER_MESSAGE = config['NOTIFICATION_EMAIL']['APPROVER_MESSAGE']
REQUESTOR_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_MESSAGE']
REQUESTOR_REJECT_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_REJECT_MESSAGE']
VENDOR_ACKNOWLEDGE_MESSAGE = config['NOTIFICATION_EMAIL']['VENDOR_ACKNOWLEDGE_MESSAGE']
REQUESTOR_ACKNOWLEDGE_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_ACKNOWLEDGE_MESSAGE']
REQUESTOR_COMPLETION_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_COMPLETION_MESSAGE']
VENDOR_ACCEPTANCE_MESSAGE = config['NOTIFICATION_EMAIL']['VENDOR_ACCEPTANCE_MESSAGE']
VENDOR_REJECT_MESSAGE = config['NOTIFICATION_EMAIL']['VENDOR_REJECT_MESSAGE']
REVISED_MESSAGE = config['NOTIFICATION_EMAIL']['REVISED_MESSAGE']
CANCEL_MESSAGE = config['NOTIFICATION_EMAIL']['CANCEL_MESSAGE']
APPROVER_REJECT_MESSAGE = config['NOTIFICATION_EMAIL']['APPROVER_REJECT_MESSAGE']
#ADMIN PROFILE
CATCH_EMAIL = config['DEMO']['CATCH_EMAIL']
CR_FRONT_LINK = config['DEMO']['CR_LINK']
CORS_ORIGIN_ALLOW_ALL = True
config/settings/dev.py deleted 100644 → 0
View file @ cde3f61d
from .base import *
import configparser
DEBUG = True
ALLOWED_HOSTS = ['*']
# CORS_ORIGIN_ALLOW_ALL = True
config = configparser.ConfigParser()
config_file = os.path.join('./', 'env.ini')
config.read(config_file)
CHANNEL_LAYERS = {
'default': {
'BACKEND': 'channels_redis.core.RedisChannelLayer',
'CONFIG': {
"hosts": [('172.17.0.1', 6379)],
# "hosts": [('127.0.0.1', 6379)],
},
},
}
DATABASES = {
'default': {
'ENGINE': config['DEV']['DATABASE_ENGINE'],
'NAME': config['DEV']['DATABASE_NAME'],
'USER': config['DEV']['DATABASE_USER'],
'PASSWORD': config['DEV']['DATABASE_PASSWORD'],
'HOST': config['DEV']['DATABASE_HOST'],
'PORT': config['DEV']['DATABASE_PORT'],
}
}
# ****************
# PROGRAM SETTINGS
# ****************
SESSION_TIMEOUT = config['DEV']['SESSION_TIMEOUT']
FRONT_END_URL = config['DEV']['FRONT_END_URL']
AUTH_ACCESSS_TOKEN_TIMEOUT = config['DEV']['AUTH_ACCESSS_TOKEN_TIMEOUT']
USER_DEFAULT_PASSWORD = config['DEV']['USER_DEFAULT_PASSWORD']
REALTIMESERVER_IP = config['DEV']['REALTIMESERVER_IP']
# Notification Messages
APPROVER_MESSAGE = config['NOTIFICATION_EMAIL']['APPROVER_MESSAGE']
REQUESTOR_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_MESSAGE']
REQUESTOR_REJECT_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_REJECT_MESSAGE']
VENDOR_ACKNOWLEDGE_MESSAGE = config['NOTIFICATION_EMAIL']['VENDOR_ACKNOWLEDGE_MESSAGE']
REQUESTOR_ACKNOWLEDGE_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_ACKNOWLEDGE_MESSAGE']
REQUESTOR_COMPLETION_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_COMPLETION_MESSAGE']
VENDOR_ACCEPTANCE_MESSAGE = config['NOTIFICATION_EMAIL']['VENDOR_ACCEPTANCE_MESSAGE']
VENDOR_REJECT_MESSAGE = config['NOTIFICATION_EMAIL']['VENDOR_REJECT_MESSAGE']
REVISED_MESSAGE = config['NOTIFICATION_EMAIL']['REVISED_MESSAGE']
CANCEL_MESSAGE = config['NOTIFICATION_EMAIL']['CANCEL_MESSAGE']
APPROVER_REJECT_MESSAGE = config['NOTIFICATION_EMAIL']['APPROVER_REJECT_MESSAGE']
#ADMIN PROFILE
CATCH_EMAIL = config['DEV']['CATCH_EMAIL']
CR_FRONT_LINK = config['DEV']['CR_LINK']
CORS_ORIGIN_ALLOW_ALL = True
config/settings/sit.py deleted 100644 → 0
View file @ cde3f61d
from .base import *
import configparser
DEBUG = True
ALLOWED_HOSTS = ['*']
config = configparser.ConfigParser()
config_file = os.path.join('./', 'env.ini')
config.read(config_file)
CHANNEL_LAYERS = {
'default': {
'BACKEND': 'channels_redis.core.RedisChannelLayer',
'CONFIG': {
"hosts": [('172.17.0.1', 6379)],
# "hosts": [('127.0.0.1', 6379)],
},
},
}
DATABASES = {
'default': {
'ENGINE': config['SIT']['DATABASE_ENGINE'],
'NAME': config['SIT']['DATABASE_NAME'],
'USER': config['SIT']['DATABASE_USER'],
'PASSWORD': config['SIT']['DATABASE_PASSWORD'],
'HOST': config['SIT']['DATABASE_HOST'],
'PORT': config['SIT']['DATABASE_PORT'],
}
}
# ****************
# PROGRAM SETTINGS
# ****************
SESSION_TIMEOUT = config['SIT']['SESSION_TIMEOUT']
FRONT_END_URL = config['SIT']['FRONT_END_URL']
AUTH_ACCESSS_TOKEN_TIMEOUT = config['SIT']['AUTH_ACCESSS_TOKEN_TIMEOUT']
USER_DEFAULT_PASSWORD = config['SIT']['USER_DEFAULT_PASSWORD']
REALTIMESERVER_IP = config['SIT']['REALTIMESERVER_IP']
# Notification Messages
APPROVER_MESSAGE = config['NOTIFICATION_EMAIL']['APPROVER_MESSAGE']
REQUESTOR_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_MESSAGE']
REQUESTOR_REJECT_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_REJECT_MESSAGE']
VENDOR_ACKNOWLEDGE_MESSAGE = config['NOTIFICATION_EMAIL']['VENDOR_ACKNOWLEDGE_MESSAGE']
REQUESTOR_ACKNOWLEDGE_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_ACKNOWLEDGE_MESSAGE']
REQUESTOR_COMPLETION_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_COMPLETION_MESSAGE']
VENDOR_ACCEPTANCE_MESSAGE = config['NOTIFICATION_EMAIL']['VENDOR_ACCEPTANCE_MESSAGE']
VENDOR_REJECT_MESSAGE = config['NOTIFICATION_EMAIL']['VENDOR_REJECT_MESSAGE']
REVISED_MESSAGE = config['NOTIFICATION_EMAIL']['REVISED_MESSAGE']
CANCEL_MESSAGE = config['NOTIFICATION_EMAIL']['CANCEL_MESSAGE']
APPROVER_REJECT_MESSAGE = config['NOTIFICATION_EMAIL']['APPROVER_REJECT_MESSAGE']
#ADMIN PROFILE
CATCH_EMAIL = config['SIT']['CATCH_EMAIL']
CR_FRONT_LINK = config['SIT']['CR_LINK']
CORS_ORIGIN_ALLOW_ALL = True
config/settings/staging.py deleted 100644 → 0
View file @ cde3f61d
from .base import *
import configparser
DEBUG = False
ALLOWED_HOSTS = ['*']
config = configparser.ConfigParser()
config_file = os.path.join('./', 'env.ini')
config.read(config_file)
CHANNEL_LAYERS = {
'default': {
'BACKEND': 'channels_redis.core.RedisChannelLayer',
'CONFIG': {
"hosts": [('172.17.0.1', 6379)],
# "hosts": [('127.0.0.1', 6379)],
},
},
}
DATABASES = {
'default': {
'ENGINE': config['STAGING']['DATABASE_ENGINE'],
'NAME': config['STAGING']['DATABASE_NAME'],
'USER': config['STAGING']['DATABASE_USER'],
'PASSWORD': config['STAGING']['DATABASE_PASSWORD'],
'HOST': config['STAGING']['DATABASE_HOST'],
'PORT': config['STAGING']['DATABASE_PORT'],
}
}
# ****************
# PROGRAM SETTINGS
# ****************
SESSION_TIMEOUT = config['STAGING']['SESSION_TIMEOUT']
FRONT_END_URL = config['STAGING']['FRONT_END_URL']
AUTH_ACCESSS_TOKEN_TIMEOUT = config['STAGING']['AUTH_ACCESSS_TOKEN_TIMEOUT']
USER_DEFAULT_PASSWORD = config['STAGING']['USER_DEFAULT_PASSWORD']
REALTIMESERVER_IP = config['STAGING']['REALTIMESERVER_IP']
# Notification Messages
APPROVER_MESSAGE = config['NOTIFICATION_EMAIL']['APPROVER_MESSAGE']
REQUESTOR_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_MESSAGE']
REQUESTOR_REJECT_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_REJECT_MESSAGE']
VENDOR_ACKNOWLEDGE_MESSAGE = config['NOTIFICATION_EMAIL']['VENDOR_ACKNOWLEDGE_MESSAGE']
REQUESTOR_ACKNOWLEDGE_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_ACKNOWLEDGE_MESSAGE']
REQUESTOR_COMPLETION_MESSAGE = config['NOTIFICATION_EMAIL']['REQUESTOR_COMPLETION_MESSAGE']
VENDOR_ACCEPTANCE_MESSAGE = config['NOTIFICATION_EMAIL']['VENDOR_ACCEPTANCE_MESSAGE']
VENDOR_REJECT_MESSAGE = config['NOTIFICATION_EMAIL']['VENDOR_REJECT_MESSAGE']
REVISED_MESSAGE = config['NOTIFICATION_EMAIL']['REVISED_MESSAGE']
CANCEL_MESSAGE = config['NOTIFICATION_EMAIL']['CANCEL_MESSAGE']
APPROVER_REJECT_MESSAGE = config['NOTIFICATION_EMAIL']['APPROVER_REJECT_MESSAGE']
#ADMIN PROFILE
CATCH_EMAIL = config['STAGING']['CATCH_EMAIL']
CR_FRONT_LINK = config['STAGING']['CR_LINK']
CORS_ORIGIN_ALLOW_ALL = True
media/uploads/user_format.csv
View file @ e87e33b8
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,Admin Department,DEPARTMENT-20191218-0000067,johndoe@gmail.com,123456,"cms,ams",cms,Oneberry Technologies Pte Ltd,Admin Department,DEPARTMENT-20191218-0000067,Yes,No,Yes,Yes
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,Admin Department,DEPARTMENT-20191218-0000067,,,,
,,,,,,,,,Oneberry Technologies Pte Ltd,Business Development,DEPARTMENT-20191121-0000064,,,,
,,,,,,,,,Oneberry Technologies Pte Ltd,IT Department,DEPARTMENT-20191219-0000069,,,,
,,,,,,,,,Jurong Town Corporation,Facilities Management,DEPARTMENT-20191121-0000062,,,,
,,,,,,,,,Jurong Town Corporation,Sample Department,DEPARTMENT-20191218-0000068,,,,
,,,,,,,,,Jurong Town Corporation,Security Division,DEPARTMENT-20191121-0000061,,,,
,,,,,,,,,Jurong Town Corporation,Warehouse Department,DEPARTMENT-20191121-0000065,,,,
,,,,,,,,,Oneberry Technologies Pte Ltd,Business Development,DEPARTMENT-20200122-0000003,,,,
,,,,,,,,,JTC Corporation,Security,DEPARTMENT-20200122-0000002,,,,
,,,,,,,,,Sample Company,Facilities Management,DEPARTMENT-20200130-0000004,,,,
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