Skip to content

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

fixing conflict

parent dd6e2a72
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 2081 deletions
app/applicationlayer/cms/form/serializers.py
View file @ 20f54285
<<<<<<< HEAD:app/applicationlayer/cms/form/serializers.py
from app.entities import models
from rest_framework import serializers
from django.db.models import Q
......@@ -120,126 +119,3 @@ class ChangeRequestFormHeaderSerializer(
'frm_attachments', 'frm_details')
read_only_fields = ['created', 'archived_at', 'form_code']
=======
from app.entities import models
from rest_framework import serializers
from django.db.models import Q
from app.applicationlayer.cms.utils_cr import logged_user
from drf_writable_nested import WritableNestedModelSerializer
class ChangeRequestFormApproversSerializer(
serializers.ModelSerializer
):
# def to_representation(self, instance):
# ret = super().to_representation(instance)
# try:
# user = instance.user
# user_details = get_account_details(user)
# name = user_details['name']
# group = user_details['groups'][0]['name']
# company = user_details['groups'][0]['company__name']
# ret['name'] = name
# ret['department'] = group
# ret['company'] = company
# return ret
# except Exception as e:
# ret['name'] = "none"
# ret['department'] = "none"
# ret['company'] = "none"
# return ret
class Meta:
model = models.ChangeRequestFormApprovers
fields = '__all__'
read_only_fields = ['created', 'archived_at', 'code']
class ChangeRequestFormStakeHoldersSerializer(
serializers.ModelSerializer
):
class Meta:
model = models.ChangeRequestFormStakeHolders
fields = '__all__'
read_only_fields = ['created', 'archived_at', 'code']
class ChangeRequestFormAttachmentsSerializer(
serializers.ModelSerializer
):
class Meta:
model = models.ChangeRequestFormAttachments
fields = '__all__'
read_only_fields = ['created', 'archived_at', 'code']
class ChangeRequestFormDetailsSerializer(
serializers.ModelSerializer
):
class Meta:
model = models.ChangeRequestFormDetails
fields = '__all__'
read_only_fields = ['created', 'archived_at', 'code']
class ChangeRequestFormHeaderSerializer(
WritableNestedModelSerializer
):
frm_approvers = ChangeRequestFormApproversSerializer(
many=True, required=False)
frm_stakes = ChangeRequestFormStakeHoldersSerializer(
many=True, required=False)
frm_attachments = ChangeRequestFormAttachmentsSerializer(
many=True, required=False)
frm_details = ChangeRequestFormDetailsSerializer(
many=True, required=False)
def to_representation(self, instance):
ret = super().to_representation(instance)
try:
# id_number = self.context.get('request').META.get('user')
user = self.context['request'].user
print(user)
# id_number = "USER-20190909-0000005"
current_level = models.ChangeRequestFormApprovers.objects.filter(
Q(form_code=ret['form_code']) &
Q(archived_at=None) &
(Q(action='') | Q(action=None))
).order_by('level')
if current_level.first()['user'] == 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
return ret
except Exception as e:
ret['action'] = "No"
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', 'archived_at', 'form_code']
>>>>>>> d48679c96ca8ba780357ca8f9fa91b68cfa3778b:app/applicationlayer/cms/form/serializers.py
app/applicationlayer/cms/form/views.py
View file @ 20f54285
<<<<<<< HEAD:app/applicationlayer/cms/form/views.py
from django.shortcuts import render
from rest_framework import viewsets as meviewsets
......@@ -948,955 +947,4 @@ class ChangeRequestFormPost(APIView):
'message': 'Request was not able to process' + str(e),
}
return Response(message,
=======
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
from app.businesslayer.changerequest import change_request
from app.applicationlayer.cms.utils_cr import number_generator
from app.entities import enums
from django.forms.models import model_to_dict
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
queryset = models.ChangeRequestFormHeader.objects.all()
lookup_field = 'form_code'
def list(self, request, *args, **kwargs):
id_number = self.request.user
# print(id_number.code)
self.queryset = change_request.list_by_user(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'),
)
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)
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
print(id_number)
self.queryset = change_request.list_by_user(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'),
)
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.code,
'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
self.queryset = change_request.list_by_user(id_number.code)
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)
# self.queryset = QuerySetHelper.Filter(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
self.queryset = change_request.list_by_user(id_number.code)
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
self.queryset = change_request.list_by_user(id_number.code)
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')
self.queryset = QuerySetHelper.Sort(self)
return super(ChangeRequestFormsViewset, self).list(request)
def retrieve(self, request, *args, **kwargs):
instance = self.queryset.filter(
archived_at=None,
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):
form_code = kwargs['form_code']
print(form_code)
models.ChangeRequestFormHeader.objects.filter(
form_code=form_code).update(status='Pending')
models.ChangeRequestFormApprovers.objects.filter(
form_code=form_code).update(action=None, remarks=None,
date_sent=None)
return Response(
"Change request form successfully re routed",
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):
# get form code to be re created
form_code = kwargs['form_code']
frm_id = models.ChangeRequestFormHeader.objects.get(
form_code=form_code)
obj = models.ChangeRequestFormHeader.objects.get(pk=frm_id.pk)
obj.pk = None
obj.form_code = "Temp-Form-Code"
obj.old_form_code = form_code
obj.status = 'Draft'
obj.save()
new_frmheader_code = number_generator(
enums.GenerateCode.FORM.value, obj.id)
models.ChangeRequestFormHeader.objects.filter(
pk=obj.id).update(form_code=new_frmheader_code)
# re create approvers
approvers = models.ChangeRequestFormApprovers.objects.filter(
form_code=form_code)
counter = 0
for approver in approvers:
to_delete = approver.pk
counter = counter + 1
approver.pk = None
approver.code = counter
approver.remarks =None
approver.action = None
approver.date_sent = None
approver.save()
new_frmapp_code = number_generator(
enums.GenerateCode.FORM_APPROVER.value, approver.id)
models.ChangeRequestFormApprovers.objects.filter(
pk=approver.id).update(code=new_frmapp_code,
form_code=new_frmheader_code)
# delete old data
models.ChangeRequestFormApprovers.objects.filter(
pk=to_delete).delete()
# re create stakeholders
stakes = models.ChangeRequestFormStakeHolders.objects.filter(
form_code=form_code)
counter = 0
for stake in stakes:
to_delete = stake.pk
counter = counter + 1
stake.pk = None
stake.code = counter
stake.save()
new_frmstake_code = number_generator(
enums.GenerateCode.FORM_STAKE.value, stake.id)
models.ChangeRequestFormStakeHolders.objects.filter(
pk=stake.id).update(code=new_frmstake_code,
form_code=new_frmheader_code)
# delete old data
models.ChangeRequestFormStakeHolders.objects.filter(
pk=to_delete).delete()
# re create details
details = models.ChangeRequestFormDetails.objects.filter(
form_code=form_code)
counter = 0
for detail in details:
to_delete = detail.pk
counter = counter + 1
detail.pk = None
detail.code = counter
detail.save()
new_frmdetail_code = number_generator(
enums.GenerateCode.FORM_DETAIL.value, detail.id)
models.ChangeRequestFormDetails.objects.filter(
pk=detail.id).update(code=new_frmdetail_code,
form_code=new_frmheader_code)
# delete old data
models.ChangeRequestFormDetails.objects.filter(
pk=to_delete).delete()
# re create attachments
attachments = models.ChangeRequestFormAttachments.objects.filter(
form_code=form_code)
counter = 0
for attachment in attachments:
to_delete = attachment.pk
counter = counter + 1
attachment.pk = None
attachment.code = counter
attachment.save()
new_frmattach_code = number_generator(
enums.GenerateCode.FORM_ATTACH.value, attachment.id)
models.ChangeRequestFormAttachments.objects.filter(
pk=attachment.id).update(code=new_frmattach_code,
form_code=new_frmheader_code)
# delete old data
models.ChangeRequestFormAttachments.objects.filter(
pk=to_delete).delete()
# delete old data form header
models.ChangeRequestFormHeader.objects.filter(
form_code=form_code).delete()
return Response(
"Change request form successfully resubmitted",
status=status.HTTP_200_OK
)
# actions
@action(
methods=['PATCH'], detail=True,
url_path='actions', url_name='actions'
)
def actions(self, request, *args, **kwargs):
form_code = kwargs['form_code']
print(form_code)
models.ChangeRequestFormHeader.objects.filter(
form_code=form_code).update(status='Pending')
models.ChangeRequestFormApprovers.objects.filter(
form_code=form_code).update(action=None, remarks=None,
date_sent=None)
return Response(
"Change request form successfully re routed",
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 create(self, request, *args, **kwargs):
# ObjectId = request.data.get('id')
# sent = False
# if 'form_status' in request.data:
# # for email
# if str(request.data['level']) == '1' and request.data['form_status'].lower() == 'pending':
# user = request.data['user']
# form_code = request.data['form_code']
# delegation = request.data['delegation']
# # initial_email(user, form_code, delegation)
# # EMAIL CODE FOR APPROVER
# notification_msg = APPROVER_MESSAGE.split(';')[0]
# email_code = APPROVER_MESSAGE.split(';')[1]
# next_appover_email(
# user, form_code, delegation,
# notification_msg, 'initial', email_code
# )
# request.data['date_sent'] = datetime.now().strftime('%Y-%m-%d, %H:%M:%S')
# request.data['created'] = datetime.now().strftime('%Y-%m-%d, %H:%M:%S') #correct
# sent = True
# serializer = self.get_serializer(data=request.data)
# serializer.is_valid(raise_exception=True)
# if ObjectId:
# dbExisting = models.ChangeRequestFormApprovers.objects.filter(
# id=ObjectId,
# archived_at=None).first()
# if dbExisting:
# dbExisting.archived_at = datetime.now()
# dbExisting.save()
# # x = self.perform_create(serializer)
# serializer.id = None
# x = serializer.save()
# if sent == True:
# x.date_sent = datetime.now().strftime('%Y-%m-%d, %H:%M:%S')
# x.created = datetime.now().strftime('%Y-%m-%d, %H:%M:%S') #correct
# x.save()
# headers = self.get_success_headers(serializer.data)
# return Response(
# serializer.data,
# status=status.HTTP_201_CREATED,
# headers=headers
# )
@action(
methods=['PATCH'], detail=False,
url_path='approved', url_name='approved'
)
def approved(self, request, *args, **kwargs):
objectid = request.data['id']
instance = models.ChangeRequestFormApprovers.objects.filter(
id=objectid
)
instance = instance.first()
current_remarks = instance.remarks
instance.update(
set__archived_at=datetime.utcnow()
)
request.data['created'] = datetime.now().strftime('%Y-%m-%d, %H:%M:%S') # correct
print("hello")
print(request.data['remarks'])
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
#------------
id = serializer.data['id']
current_user = request.data['user']
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']
next_approver = models.ChangeRequestFormApprovers.objects.filter(
level=str(next_level),
form_code=form_code,
archived_at=None
)
if action.lower() == 'approved':
models.ChangeRequestFormApprovers.objects.filter(
Q(archived_at=None) & Q(level=str(next_level))
).update(
date_sent=datetime.now().strftime('%Y-%m-%d, %H:%M:%S')
)
# EMAIL CODE FOR REQUESTOR
requestor_notification_msg = REQUESTOR_MESSAGE.split(';')[0]
requestor_email_code = REQUESTOR_MESSAGE.split(';')[1]
# EMAIL CODE FOR APPROVER
notification_msg = APPROVER_MESSAGE.split(';')[0]
email_code = APPROVER_MESSAGE.split(';')[1]
send_mail_requestor(
current_user, form_code, delegation,
requestor_notification_msg, action, requestor_email_code,
remarks, level
)
for n_approver in next_approver:
print(n_approver.user)
if n_approver.delegation.lower() == 'vendor/implementor':
notification_msg = VENDOR_ACKNOWLEDGE_MESSAGE.split(';')[0]
email_code = VENDOR_ACKNOWLEDGE_MESSAGE.split(';')[1]
next_appover_email(
n_approver.user, form_code, delegation,
notification_msg, action, email_code
)
elif action.lower() == 'rejected':
if delegation.lower() == 'requestor':
notification_msg = VENDOR_REJECT_MESSAGE.split(';')[0]
email_code = VENDOR_REJECT_MESSAGE.split(';')[1]
send_mail_vendor(
current_user, form_code, delegation,
requestor_notification_msg, action, requestor_email_code,
remarks, level
)
else:
# EMAIL CODE FOR REQUESTOR
requestor_notification_msg = REQUESTOR_REJECT_MESSAGE.split(';')[0]
requestor_email_code = REQUESTOR_REJECT_MESSAGE.split(';')[1]
send_mail_requestor(
current_user, form_code, delegation,
requestor_notification_msg, action, requestor_email_code,
remarks, level
)
elif action.lower() == 'completed':
models.ChangeRequestFormApprovers.objects.filter(
Q(archived_at=None) & Q(level=str(next_level))
).update(
date_sent=datetime.now().strftime('%Y-%m-%d, %H:%M:%S')
)
# EMAIL CODE FOR REQUESTOR
requestor_notification_msg = REQUESTOR_COMPLETION_MESSAGE.split(';')[0]
requestor_email_code = REQUESTOR_COMPLETION_MESSAGE.split(';')[1]
send_mail_requestor(
current_user, form_code, delegation,
requestor_notification_msg, action, requestor_email_code,
remarks, level
)
elif action.lower() == 'acknowledged':
# models.ChangeRequestFormApprovers.objects.filter(
# level=str(next_level)
# ).update(
# date_sent=datetime.now().strftime('%Y-%m-%d, %H:%M:%S')
# )
# EMAIL CODE FOR REQUESTOR
requestor_notification_msg = REQUESTOR_ACKNOWLEDGE_MESSAGE.split(';')[0]
requestor_email_code = REQUESTOR_ACKNOWLEDGE_MESSAGE.split(';')[1]
send_mail_requestor(
current_user, form_code, delegation,
requestor_notification_msg, action, requestor_email_code,
remarks, level
)
elif action.lower() == 'accepted':
# EMAIL CODE FOR VENDOR
requestor_notification_msg = VENDOR_ACCEPTANCE_MESSAGE.split(';')[0]
requestor_email_code = VENDOR_ACCEPTANCE_MESSAGE.split(';')[1]
send_mail_vendor(
current_user, form_code, delegation,
requestor_notification_msg, action, requestor_email_code,
remarks, level
)
# elif action.lower() == 'cancelled':
# action_cancelled(self, request, *args, **kwargs)
headers = self.get_success_headers(serializer.data)
return Response(
serializer.data, status=status.HTTP_201_CREATED
)
#------------
def list(self, request, *args, **kwargs):
self.queryset = self.queryset.filter(archived_at=None)
self.queryset = QuerySetHelper.Sort(self)
self.queryset = QuerySetHelper.Filter(self)
return super(ChangeRequestFormApproversViewset, self).list(request)
def retrieve(self, request, *args, **kwargs):
instance = self.queryset.filter(archived_at=None).first()
serializer = self.get_serializer(instance)
return Response(serializer.data)
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 = self.queryset.filter(archived_at=None)
self.queryset = QuerySetHelper.Sort(self)
self.queryset = QuerySetHelper.Filter(self)
return super(
ChangeRequestFormAttachmentsViewset, self
).list(request)
def create(self, request, *args, **kwargs):
attachment_no = request.data.get('attachment_no')
ObjectId = request.data.get('id')
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
if ObjectId:
dbExisting = models.ChangeRequestFormAttachments.objects.filter(
id=ObjectId,
archived_at=None).first()
if dbExisting:
dbExisting.archived_at = datetime.now()
dbExisting.save()
self.perform_create(serializer)
if not attachment_no:
id = serializer.data['id']
db_counter = models.ChangeRequestFormAttachments.objects.all().count()
db_counter = db_counter + 1
models.ChangeRequestFormAttachments.objects.filter(id=id).update(
set__attachment_no=number_generator(
"ATCH", db_counter
)
)
headers = self.get_success_headers(serializer.data)
return Response(
serializer.data,
status=status.HTTP_201_CREATED,
headers=headers
)
def retrieve(self, request, *args, **kwargs):
instance = self.queryset.filter(archived_at=None).first()
serializer = self.get_serializer(instance)
return Response(serializer.data)
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 = self.queryset.filter(archived_at=None)
self.queryset = QuerySetHelper.Sort(self)
self.queryset = QuerySetHelper.Filter(self)
return super(ChangeRequestFormStakeHoldersViewset, self).list(request)
def create(self, request, *args, **kwargs):
ObjectId = request.data.get('id')
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
if ObjectId:
dbExisting = models.ChangeRequestFormStakeHolders.objects.filter(
id=ObjectId,
archived_at=None).first()
if dbExisting:
dbExisting.archived_at = datetime.now()
dbExisting.save()
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(
serializer.data,
status=status.HTTP_201_CREATED,
headers=headers
)
def retrieve(self, request, *args, **kwargs):
instance = self.queryset.filter(archived_at=None).first()
serializer = self.get_serializer(instance)
return Response(serializer.data)
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 = self.queryset.filter(archived_at=None)
self.queryset = QuerySetHelper.Sort(self)
self.queryset = QuerySetHelper.Filter(self)
return super(ChangeRequestFormDetailsViewset, self).list(request)
def create(self, request, *args, **kwargs):
ObjectId = request.data.get('id')
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
if ObjectId:
dbExisting = models.ChangeRequestFormDetails.objects.filter(
id=ObjectId,
archived_at=None).first()
if dbExisting:
dbExisting.archived_at = datetime.now()
dbExisting.save()
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(
serializer.data,
status=status.HTTP_201_CREATED,
headers=headers
)
def retrieve(self, request, *args, **kwargs):
instance = self.queryset.filter(archived_at=None).first()
serializer = self.get_serializer(instance)
return Response(serializer.data)
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'],
'old_form_code': form_header['old_form_code'],
'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']
}
frm_approvers = form_header['frm_approvers']
frm_stakes = form_header['frm_stakes']
frm_attachments = form_header['frm_attachments']
frm_details = form_header['frm_details']
# sp1 = transaction.savepoint() # nothing will save to db
serializer = serializers.ChangeRequestFormHeaderSerializer(
data=form_header_data)
if serializer.is_valid(raise_exception=True):
serializer.save()
template_no = serializer.data['template_no']
tmp_counter = models.ChangeRequestFormHeader.objects.filter(
template_no=template_no).count()
# tmp_counter = tmp_counter + 1
CR_Prefix = serializer.data['requested_to_template_id']
generate_tmp = number_generator(CR_Prefix, tmp_counter)
frm_id = serializer.data['form_code']
print(frm_id)
models.ChangeRequestFormHeader.objects.filter(
form_code=frm_id).update(
requested_to_template_id=generate_tmp)
# create template approvers
for frm_approver in frm_approvers:
frm_approver['form_code'] = frm_id
data_list_approver.append(frm_approver)
serializerApprover = serializers.ChangeRequestFormApproversSerializer(
data=data_list_approver, many=True)
if serializerApprover.is_valid(raise_exception=True):
serializerApprover.save()
# create template 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
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
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()
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,
>>>>>>> d48679c96ca8ba780357ca8f9fa91b68cfa3778b:app/applicationlayer/cms/form/views.py
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
\ No newline at end of file
app/applicationlayer/cms/template/serializers.py
View file @ 20f54285
<<<<<<< HEAD
from app.entities import models
from rest_framework import serializers
from django.db.models import Q
......@@ -64,71 +63,4 @@ class ChangeRequestTemplatesSerializer(
'created_by_user', 'created_by_department', 'tmp_approvers',
'tmp_stakes', 'tmp_attachments', 'tmp_details')
=======
from app.entities import models
from rest_framework import serializers
from django.db.models import Q
from drf_writable_nested import WritableNestedModelSerializer
class ChangeRequestTemplateApproversSerializer(
serializers.ModelSerializer
):
class Meta:
model = models.ChangeRequestTemplateApprovers
fields = '__all__'
read_only_fields = ['created', 'archived_at', 'code']
class ChangeRequestTemplateStakeHoldersSerializer(
serializers.ModelSerializer
):
class Meta:
model = models.ChangeRequestTemplateStakeHolders
fields = '__all__'
read_only_fields = ['created', 'archived_at', 'code']
class ChangeRequestTemplateAttachmentsSerializer(
serializers.ModelSerializer
):
class Meta:
model = models.ChangeRequestTemplateAttachments
fields = '__all__'
read_only_fields = ['created', 'archived_at', 'code']
class ChangeRequestTemplateDetailsSerializer(
serializers.ModelSerializer
):
class Meta:
model = models.ChangeRequestTemplateDetails
fields = '__all__'
read_only_fields = ['created', 'archived_at', 'code']
# comment
class ChangeRequestTemplatesSerializer(
WritableNestedModelSerializer
):
tmp_approvers = ChangeRequestTemplateApproversSerializer(
many=True, required=False)
tmp_stakes = ChangeRequestTemplateStakeHoldersSerializer(
many=True, required=False)
tmp_attachments = ChangeRequestTemplateAttachmentsSerializer(
many=True, required=False)
tmp_details = ChangeRequestTemplateDetailsSerializer(
many=True, required=False)
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')
>>>>>>> d48679c96ca8ba780357ca8f9fa91b68cfa3778b
read_only_fields = ['created', 'archived_at', 'template_no']
\ No newline at end of file
app/applicationlayer/cms/template/views.py
View file @ 20f54285
<<<<<<< HEAD
from django.shortcuts import render
from rest_framework import viewsets as meviewsets
......@@ -338,345 +337,4 @@ class ChangeRequestTemplateDetailsViewset(meviewsets.ModelViewSet):
def retrieve(self, request, *args, **kwargs):
instance = self.queryset.filter(archived_at=None).first()
serializer = self.get_serializer(instance)
=======
from django.shortcuts import render
from rest_framework import viewsets as meviewsets
from rest_framework.views import APIView
from app.applicationlayer.cms.template import serializers
from app.entities import models
from app.applicationlayer import paginators
from datetime import datetime
from datetime import timedelta
from rest_framework.response import Response
from rest_framework import status, views
from rest_framework.decorators import action
from django.http import Http404
from django.db.models import Q
import requests
from django.conf import settings
from rest_framework.exceptions import ValidationError
from django.db import transaction, IntegrityError, connection
from app.applicationlayer.utils import QuerySetHelper
from app.businesslayer.changerequest import change_request
from app.applicationlayer.cms.utils_cr import number_generator, crhistory_save
from django.shortcuts import get_object_or_404
from rest_framework.generics import GenericAPIView
from rest_framework.mixins import UpdateModelMixin
from django.forms.models import model_to_dict
from app.entities import enums
class ChangeRequestTemplatesViewset(meviewsets.ModelViewSet):
queryset = models.ChangeRequestTemplateHeader.objects.all()
lookup_field = 'template_no'
serializer_class = serializers.ChangeRequestTemplatesSerializer
pagination_class = paginators.SimplePageNumberPagination
def list(self, request, *args, **kwargs):
self.queryset = self.queryset.order_by('-created')
self.queryset = QuerySetHelper.Sort(self)
return super(ChangeRequestTemplatesViewset, self).list(request)
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)
def destroy(self, request, *args, **kwargs):
try:
template_no = self.kwargs['template_no']
instance = models.ChangeRequestTemplateHeader.objects.filter(
Q(template_no=template_no) &
Q(archived_at=None)
).update(archived_at=datetime.now())
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', False)
instance = self.get_object()
template_no = kwargs['template_no']
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
# print(new_instance)
crhistory_save(
enums.LogEnum.UPDATE.value,
enums.CREntitiesEnum.CR_TMP_HEADER.value,
new_instance['template_no'],
old_instance,
new_instance
)
return Response(serializer.data)
return Response(
"Unable to edit due to existing transaction",
status=status.HTTP_400_BAD_REQUEST
)
@action(
methods=['PATCH'], detail=True,
url_path='archived', url_name='archived'
)
def archived(self, request, *args, **kwargs):
template_no = kwargs['template_no']
tmp_no_exists = models.ChangeRequestFormHeader.objects.filter(
template_no=template_no)
if not tmp_no_exists:
models.ChangeRequestTemplateDetails.objects.filter(
template_no=template_no
).update(archived_at=datetime.now())
models.ChangeRequestTemplateAttachments.objects.filter(
template_no=template_no
).update(archived_at=datetime.now())
models.ChangeRequestTemplateHeader.objects.filter(
template_no=template_no
).update(archived_at=datetime.now())
models.ChangeRequestTemplateApprovers.objects.filter(
template_no=template_no
).update(archived_at=datetime.now())
models.ChangeRequestTemplateStakeHolders.objects.filter(
template_no=template_no
).update(archived_at=datetime.now())
return Response(
"Template successfully archived",
status=status.HTTP_200_OK
)
return Response(
"Unable to archive 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']
}
tmp_approvers = template_header['tmp_approvers']
tmp_stakes = template_header['tmp_stakes']
tmp_attachments = template_header['tmp_attachments']
tmp_details = template_header['tmp_details']
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
for tmp_approver in tmp_approvers:
tmp_approver['template_no'] = tmp_id
data_list_approver.append(tmp_approver)
serializerApprover = serializers.ChangeRequestTemplateApproversSerializer(
data=data_list_approver, many=True)
if serializerApprover.is_valid(raise_exception=True):
serializerApprover.save()
# create template stakes
for tmp_stake in tmp_stakes:
tmp_stake['template_no'] = tmp_id
data_list_stake.append(tmp_stake)
serializerStake = serializers.ChangeRequestTemplateStakeHoldersSerializer(
data=data_list_stake, many=True)
if serializerStake.is_valid(raise_exception=True):
serializerStake.save()
# create template attachments
for tmp_attachment in tmp_attachments:
tmp_attachment['template_no'] = tmp_id
data_list_attach.append(tmp_attachment)
serializerAttach = serializers.ChangeRequestTemplateAttachmentsSerializer(
data=data_list_attach, many=True)
if serializerAttach.is_valid(raise_exception=True):
serializerAttach.save()
# create template details
for tmp_detail in tmp_details:
tmp_detail['template_no'] = tmp_id
data_list_detail.append(tmp_detail)
serializerDetail = serializers.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)
class ChangeRequestTemplateApproversViewset(meviewsets.ModelViewSet):
queryset = models.ChangeRequestTemplateApprovers.objects.all()
serializer_class = serializers.ChangeRequestTemplateApproversSerializer
pagination_class = paginators.SimplePageNumberPagination
lookup_field = "code"
def list(self, request, *args, **kwargs):
self.queryset = self.queryset.filter(archived_at=None)
self.queryset = QuerySetHelper.Sort(self)
return super(ChangeRequestTemplateApproversViewset, self).list(request)
def retrieve(self, request, *args, **kwargs):
instance = self.queryset.filter(archived_at=None).first()
serializer = self.get_serializer(instance)
return Response(serializer.data)
class ChangeRequestTemplateAttachmentsViewset(meviewsets.ModelViewSet):
queryset = models.ChangeRequestTemplateAttachments.objects.all()
serializer_class = serializers.ChangeRequestTemplateAttachmentsSerializer
pagination_class = paginators.SimplePageNumberPagination
lookup_field = "code"
def list(self, request, *args, **kwargs):
self.queryset = self.queryset.filter(archived_at=None)
self.queryset = QuerySetHelper.Sort(self)
return super(
ChangeRequestTemplateAttachmentsViewset, self
).list(request)
def retrieve(self, request, *args, **kwargs):
instance = self.queryset.filter(archived_at=None).first()
serializer = self.get_serializer(instance)
return Response(serializer.data)
class ChangeRequestTemplateStakeHoldersViewset(meviewsets.ModelViewSet):
queryset = models.ChangeRequestTemplateStakeHolders.objects.all()
serializer_class = serializers.ChangeRequestTemplateStakeHoldersSerializer
pagination_class = paginators.SimplePageNumberPagination
lookup_field = "code"
def list(self, request, *args, **kwargs):
self.queryset = self.queryset.filter(archived_at=None)
self.queryset = QuerySetHelper.Sort(self)
return super(ChangeRequestTemplateStakeHoldersViewset, self).list(request)
def retrieve(self, request, *args, **kwargs):
instance = self.queryset.filter(archived_at=None).first()
serializer = self.get_serializer(instance)
return Response(serializer.data)
class ChangeRequestTemplateDetailsViewset(meviewsets.ModelViewSet):
queryset = models.ChangeRequestTemplateDetails.objects.all()
serializer_class = serializers.ChangeRequestTemplateDetailsSerializer
pagination_class = paginators.SimplePageNumberPagination
lookup_field = "code"
def list(self, request, *args, **kwargs):
self.queryset = self.queryset.filter(archived_at=None)
self.queryset = QuerySetHelper.Sort(self)
return super(ChangeRequestTemplateDetailsViewset, self).list(request)
def retrieve(self, request, *args, **kwargs):
instance = self.queryset.filter(archived_at=None).first()
serializer = self.get_serializer(instance)
>>>>>>> d48679c96ca8ba780357ca8f9fa91b68cfa3778b
return Response(serializer.data)
\ No newline at end of file
app/applicationlayer/cms/utils_cr.py
View file @ 20f54285
<<<<<<< HEAD:app/applicationlayer/cms/utils_cr.py
from datetime import datetime
from django.db.models.functions import Lower
from functools import wraps
......@@ -447,454 +446,4 @@ def crhistory_save(action, entity, form_code, fromValue, toValue):
fromValue=fromValue,
toValue=toValue
)
=======
from datetime import datetime
from django.db.models.functions import Lower
from functools import wraps
from django.conf import settings
import requests
from app.entities import models
from datetime import timedelta
from django.db.models import Q
# from dateutil import parser
# EMAIL = settings.EMAIL
# ACCOUNTS = settings.ACCOUNTS
# GROUPS = settings.GROUPS
# COMPANIES = settings.COMPANIES
# ALLOWED_COMPANY = settings.ALLOWED_COMPANY
# CR_FRONT_LINK = settings.CR_FRONT_LINK
# NOTIFICATION = settings.NOTIFICATION
def get_group_details(group_no):
return requests.get(f'{GROUPS}?group_no={group_no}').json()['results'][0]
def get_companies_details(slug):
return requests.get(f'{COMPANIES}?slug={slug}').json()['results'][0]
def get_account_details(id_number):
return requests.get(f'{ACCOUNTS}?id_number={id_number}').json()['results'][0]
def get_allowed_company(id_number):
return requests.get(f'{ALLOWED_COMPANY}?id_number={id_number}')
class QuerySetHelper:
@staticmethod
def Sort(context):
sort_field = context.request.query_params.get('sort_field')
sort_order = context.request.query_params.get('sort_order')
if sort_field and sort_order:
if sort_order.lower() == 'asc':
context.queryset = context.queryset.order_by(sort_field)
else:
context.queryset = context.queryset.order_by(f"-{sort_field}")
return context.queryset
@staticmethod
def Search(context):
search_field = context.request.query_params.get('search-field')
search_key = context.request.query_params.get('search-key')
if search_field and search_key:
context.queryset = context.queryset(
__raw__={f"{search_field}" : {"$regex" : f".*{search_key.lower()}.*"}}
)
return context.queryset
@staticmethod
def SearchDynamic(base_queryset,
):
search_field = context.request.query_params.get('search-field')
search_key = context.request.query_params.get('search-key')
if search_field and search_key:
context.queryset = context.queryset(
__raw__={f"{search_field}" : {"$regex" : f".*{search_key.lower()}.*"}}
)
return context.queryset
# 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 = QuerySetHelper.Sort(self)
@staticmethod
def Filter(context):
if int(len(context.request.query_params)) > 0:
filtering_kwargs = {}
with_params = []
common_params = (
'page', 'page-size', 'page_size', 'sort_order', 'sort_field'
)
for field, value in context.request.GET.items():
filtering_kwargs = {}
if value and field.lower() not in common_params:
filtering_kwargs[field] = {"$regex" : f".*{value.lower()}.*"}
filtering_kwargs[field] = {"$regex" : f".*{value}.*"}
# filtering_kwargs[field] = {"$regex" : f".*{value.lower()}.*"}
with_params.append(filtering_kwargs)
raw_query = {"$or": with_params}
context.queryset = context.queryset(__raw__=raw_query)
return context.queryset
def ApproverStatus(status):
choices = ["pending", "rejected", "approved", "completed", "cancelled", 'acknowledged', 'accepted']
if status not in choices:
return False
else:
return True
def number_generator(prefix, id):
date = '{:%Y%m%d}'.format(datetime.now())
id_num = '{:07}'.format(id)
autogenerated_no = prefix + '-' + date + '-' + id_num
return autogenerated_no
def logged_user(self):
# return self.request.META.get('HTTP_ACCOUNT_NO')
return self.request.user
def receiver_body(
sender_account_no, receiver_account_no,
email_code, email_recipient,
app, sent, name, routing_level,
status, cr_number, cr_name,
company_requestedto,
department_requestedto,
priority_level, url
):
receiver_data = {
"sender_account_no": sender_account_no,
"receiver_account_no": receiver_account_no,
"email_code": email_code,
"email_recipient": email_recipient,
"app": app,
"sent": "False",
"name": name,
"routing_level": routing_level,
"status": status,
"cr_number": cr_number,
"cr_name": cr_name,
"company_requestedto": company_requestedto,
"department_requestedto": department_requestedto,
"priority_level": priority_level,
"url": url
}
return receiver_data
def get_template_instance(form_code):
template_instance = models.ChangeRequestFormHeader.objects.filter(
Q(form_code=form_code) &
Q(archived_at=None)
).first()
return template_instance
def send_notification(
form_code, cr_number, user_id_number,
user_name, message, app,
sender_id_number, sender_name
):
notification_data = {
"slug": form_code,
"change_request_template_code": cr_number,
# (OPENING TAG) receiver credential
"account_no": user_id_number,
"user": user_name,
# (CLOSING TAG) receiver credential
"notif_type": "ACTIVITY",
"message": message,
"is_read": False,
"app": app,
"sender_account_no": sender_id_number,
"createdby": sender_name
}
notification = requests.post(NOTIFICATION, data=notification_data)
# return notification.status
return notification
def send_mail_vendor(receiver,
form_code,
delegation,
msg,
action,
code,
remarks,
routing_level):
app = 'cms'
cr_link = f'{CR_FRONT_LINK}/{form_code}'
template_instance = get_template_instance(form_code)
cr_number = template_instance.requested_to_template_id
template_name = template_instance.requested_to_template_name
requested_to_company = template_instance.requested_to_company
requested_to_department = template_instance.requested_to_department
requested_by_user = template_instance.requested_by_user
created = template_instance.created
requested_to_priority = template_instance.requested_to_priority
vendor_instance = models.ChangeRequestFormApprovers.objects.filter(
Q(delegation="Vendor/Implementor") &
Q(form_code=form_code)
).first()
# receiver details
vendor = get_account_details(vendor_instance.user)
requestor_name = vendor['name']
requestor_email = vendor['email']
requestor_account_id = vendor['id_number']
# sender details
sender_instance = get_account_details(receiver)
sender_account_username = sender_instance['username']
sender_account_id = sender_instance['id_number']
sender_name = sender_instance['name']
group = get_group_details(requested_to_department)
group_name = group['name']
company = get_companies_details(requested_to_company)
company_name = company['name']
container = receiver_body(
sender_account_id, requestor_account_id, code,
requestor_email, app, "False", requestor_name, routing_level,
action, cr_number, template_name, company_name, group_name,
requested_to_priority, cr_link
)
if action.lower() == 'rejected':
new_body = {"rejected_by": requestor_name,
"remarks": remarks}
elif action.lower() == 'accepted':
new_body = {"approved_by": requestor_name}
data = {**container, **new_body}
email_status = requests.post(EMAIL, data=data)
message = f"{sender_name} {msg} ({template_name})"
send_notification(
form_code, cr_number,
requestor_account_id, requestor_name,
message, app,
sender_account_id, sender_account_username
)
def send_mail_requestor(receiver,
form_code,
delegation,
msg,
action,
code,
remarks,
routing_level):
cr_link = f'{CR_FRONT_LINK}/{form_code}'
template_instance = get_template_instance(form_code)
app = 'cms'
cr_number = template_instance.requested_to_template_id
template_name = template_instance.requested_to_template_name
requested_to_company = template_instance.requested_to_company
requested_to_department = template_instance.requested_to_department
requested_by_user = template_instance.requested_by_user
created = template_instance.created
requested_to_priority = template_instance.requested_to_priority
# receiver details --------------------------------------------------
requestor_instance = get_account_details(requested_by_user)
requestor_name = requestor_instance['name']
requestor_email = requestor_instance['email']
requestor_account_id = requestor_instance['id_number']
# sender details --------------------------------------------------
sender_instance = get_account_details(receiver)
sender_account_username = sender_instance['username']
sender_account_id = sender_instance['id_number']
sender_name = sender_instance['name']
group = get_group_details(requested_to_department)
group_name = group['name']
company = get_companies_details(requested_to_company)
company_name = company['name']
data = receiver_body(
sender_account_id, requestor_account_id, code,
requestor_email, app, "False", requestor_name, routing_level,
action, cr_number, template_name, company_name, group_name,
requested_to_priority, cr_link
)
if action.lower() == 'approved':
new_body = {"approved_by": sender_name}
elif action.lower() == 'rejected':
new_body = {"rejected_by": sender_name,
"remarks": remarks}
elif action.lower() == 'completed':
new_body = {"completed_by": sender_name}
elif action.lower() == 'acknowledged':
new_body = {"acknowledge_by": sender_name}
data = {**data, **new_body}
email_status = requests.post(EMAIL, data=data)
message = f"{sender_name} {msg} ({template_name})"
notif = send_notification(
form_code, cr_number,
requestor_account_id, requestor_name,
message, app,
sender_account_id, sender_account_username
)
def next_appover_email(receiver, form_code, delegation, msg, action, code):
cr_link = f'{CR_FRONT_LINK}/{form_code}'
template_instance = get_template_instance(form_code)
app = 'cms'
cr_number = template_instance.requested_to_template_id
template_name = template_instance.requested_to_template_name
requested_to_company = template_instance.requested_to_company
requested_to_department = template_instance.requested_to_department
requested_by_user = template_instance.requested_by_user
created = template_instance.created
requested_to_priority = template_instance.requested_to_priority
# for rec in receiver:
# receiver details
# if action == 'initial':
receiver_instance = get_account_details(receiver)
# else:
# receiver_instance = get_account_details(receiver.user)
receiver_name = receiver_instance['name']
receiver_email = receiver_instance['email']
receiver_account_id = receiver_instance['id_number']
# sender details
sender_instance = get_account_details(requested_by_user)
sender_account_username = sender_instance['username']
sender_account_id = sender_instance['id_number']
sender_name = sender_instance['name']
group = get_group_details(requested_to_department)
group_name = group['name']
company = get_companies_details(requested_to_company)
company_name = company['name']
data = receiver_body(
sender_account_id, receiver_account_id, code,
receiver_email, app, "False", receiver_name, 1,
"Pending", cr_number, template_name, company_name, group_name,
requested_to_priority, cr_link
)
email_status = requests.post(EMAIL, data=data)
message = f"{sender_name} {msg} ({template_name})"
notif = send_notification(
form_code, cr_number,
receiver_account_id, receiver_name,
message, app,
sender_account_id, sender_account_username
)
return True
def cancel_overdue(request):
date_submitted = datetime.now()
requestor = request.data['requested_by_user']
requestor = requests.get(f'{ACCOUNTS}{requestor}/')
requestor = requestor.json()['results']
cancel_date = date_submitted + timedelta(days=30)
cancel_date = cancel_date.strftime('%Y-%m-%d 00:00:00.000')
request.data['date_submitted'] = date_submitted
request.data['cancel_date'] = cancel_date
email_content_cancel = {
"sender_account_no": requestor['id_number'],
"receiver_account_no": requestor['id_number'],
"email_code": "RMS-CRCANCELLED",
"email_recipient": requestor['email'],
"app": "CMS",
"sent": "False",
"name": requestor['name'],
"status": "Pending",
"auto_cancel_date": cancel_date,
"cr_number": request.data['requested_to_template_id'],
"cr_name": request.data['requested_to_template_name'],
"company_requestedto": request.data['requested_to_company'],
"department_requestedto": request.data['requested_to_department'],
"priority_level": request.data['requested_to_priority'],
"url": "http://devweb.rms.oneberrysystem.com/login"
}
exist_cancel_template = models.CancelDateCR.objects.filter(
cr_number=request.data['requested_to_template_id']
)
if exist_cancel_template:
exist_cancel_template.delete()
models.CancelDateCR.objects.create(
cr_number=request.data['requested_to_template_id'],
trigger_date=cancel_date,
email_content=email_content_cancel
)
requested_to_target_date = parser.parse(
request.data['requested_to_target_date']
)
email_content_cancel['email_code'] = "RMS-CROVERDUE"
email_content_cancel['target_date'] = requested_to_target_date
overdue = requested_to_target_date + timedelta(days=30)
overdue = overdue.strftime('%Y-%m-%d 00:00:00.000')
models.TargetDateOverdue.objects.create(
cr_number=form_code,
trigger_date=overdue,
email_content=email_content_cancel
)
return True
def crhistory_save(action, entity, form_code, fromValue, toValue):
models.ChangeRequestHistory.objects.create(
action=action,
entity=entity,
form_code=form_code,
fromValue=fromValue,
toValue=toValue
)
>>>>>>> d48679c96ca8ba780357ca8f9fa91b68cfa3778b:app/applicationlayer/cms/utils_cr.py
return True
\ No newline at end of file
app/entities/migrations/0007_auto_20190911_1102.py
View file @ 20f54285
<<<<<<< HEAD
# Generated by Django 2.2 on 2019-09-11 11:02
from django.db import migrations, models
......@@ -17,23 +16,3 @@ class Migration(migrations.Migration):
field=models.CharField(max_length=255),
),
]
=======
# Generated by Django 2.2 on 2019-09-11 11:02
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('entities', '0006_emaillogs_is_sent'),
]
operations = [
migrations.AlterField(
model_name='changerequestformheader',
name='requested_to_template_id',
field=models.CharField(max_length=255),
),
]
>>>>>>> d48679c96ca8ba780357ca8f9fa91b68cfa3778b
app/entities/migrations/0008_auto_20190911_1715.py
View file @ 20f54285
<<<<<<< HEAD
# Generated by Django 2.2 on 2019-09-11 17:15
from django.db import migrations, models
......@@ -17,23 +16,3 @@ class Migration(migrations.Migration):
field=models.CharField(blank=True, max_length=255, null=True),
),
]
=======
# Generated by Django 2.2 on 2019-09-11 17:15
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('entities', '0007_auto_20190911_1102'),
]
operations = [
migrations.AlterField(
model_name='changerequesthistory',
name='form_code',
field=models.CharField(blank=True, max_length=255, null=True),
),
]
>>>>>>> d48679c96ca8ba780357ca8f9fa91b68cfa3778b
app/entities/migrations/0009_auto_20190911_1845.py
View file @ 20f54285
<<<<<<< HEAD
# Generated by Django 2.2 on 2019-09-11 18:45
from django.db import migrations
......@@ -62,68 +61,3 @@ class Migration(migrations.Migration):
new_name='archived_at',
),
]
=======
# Generated by Django 2.2 on 2019-09-11 18:45
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('entities', '0008_auto_20190911_1715'),
]
operations = [
migrations.RenameField(
model_name='changerequestformapprovers',
old_name='deleted_at',
new_name='archived_at',
),
migrations.RenameField(
model_name='changerequestformattachments',
old_name='deleted_at',
new_name='archived_at',
),
migrations.RenameField(
model_name='changerequestformdetails',
old_name='deleted_at',
new_name='archived_at',
),
migrations.RenameField(
model_name='changerequestformheader',
old_name='deleted_at',
new_name='archived_at',
),
migrations.RenameField(
model_name='changerequestformstakeholders',
old_name='deleted_at',
new_name='archived_at',
),
migrations.RenameField(
model_name='changerequesttemplateapprovers',
old_name='deleted_at',
new_name='archived_at',
),
migrations.RenameField(
model_name='changerequesttemplateattachments',
old_name='deleted_at',
new_name='archived_at',
),
migrations.RenameField(
model_name='changerequesttemplatedetails',
old_name='deleted_at',
new_name='archived_at',
),
migrations.RenameField(
model_name='changerequesttemplateheader',
old_name='deleted_at',
new_name='archived_at',
),
migrations.RenameField(
model_name='changerequesttemplatestakeholders',
old_name='deleted_at',
new_name='archived_at',
),
]
>>>>>>> d48679c96ca8ba780357ca8f9fa91b68cfa3778b
app/entities/migrations/0010_auto_20190913_1143.py
View file @ 20f54285
<<<<<<< HEAD
# Generated by Django 2.2 on 2019-09-13 11:43
from django.db import migrations
......@@ -32,38 +31,3 @@ class Migration(migrations.Migration):
name='archived_at',
),
]
=======
# Generated by Django 2.2 on 2019-09-13 11:43
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('entities', '0009_auto_20190911_1845'),
]
operations = [
migrations.RemoveField(
model_name='changerequestformapprovers',
name='archived_at',
),
migrations.RemoveField(
model_name='changerequestformattachments',
name='archived_at',
),
migrations.RemoveField(
model_name='changerequestformdetails',
name='archived_at',
),
migrations.RemoveField(
model_name='changerequestformheader',
name='archived_at',
),
migrations.RemoveField(
model_name='changerequestformstakeholders',
name='archived_at',
),
]
>>>>>>> d48679c96ca8ba780357ca8f9fa91b68cfa3778b
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