def form_valid(self, form):
form.save()
self.object.self_assessed = True
self.object.save()
NotificationManager.kra_update_notification(self.request, self.object)
messages.success(self.request, "KRA Self-assessment completed successfully")
return HttpResponseRedirect(self.object.get_absolute_url())
def post(self, request, *args, **kwargs):
kra = get_object_or_404(Kra, identifier=kwargs["identifier"])
if kra.user != request.user and kra.user.profile.manager != request.user.profile:
return Response(
utils.build_response(False, "Permission denied", None))
serializer = KraCreateMessageSerializer(data=request.data)
if serializer.is_valid():
serializer.save(
user=request.user,
kra=kra,
file_type=serializer.validated_data["file"].content_type
if "file" in serializer.validated_data
and serializer.validated_data["file"] else None,
filename=serializer.validated_data["file"].name
if "file" in serializer.validated_data
and serializer.validated_data["file"] else None)
if not kra.is_draft:
NotificationManager.kra_update_notification(request, kra)
return Response(
utils.build_response(
True, "Message sent",
KraMessagesSerializer(kra.messages.all(),
many=True,
context={
"request": request
}).data))
return Response(utils.build_response(False, None, serializer.errors))
def create(self, request, *args, **kwargs):
super(PipCreateAPIView, self).create(request, *args, **kwargs)
NotificationManager.pip_notification(self.request, self.object.staff,
self.object)
return Response(
utils.build_response(True, "PIP created successfully",
PipSerializer(self.object).data))
def post(self, request, *args, **kwargs):
form = self.get_form()
if form.is_valid():
messages.success(request, "Task created successfully")
task = form.save(False)
task.created_by = self.request.user.profile
task.save()
if task.assigned_to:
NotificationManager.task_creation_notification(request, task)
return HttpResponseRedirect(reverse_lazy("task:management"))
return self.render_to_response(self.get_context_data(form=form))
def post(self, request, *args, **kwargs):
form = self.get_form()
ratingForm = self.get_rating_form()
if form.is_valid() and ratingForm.is_valid():
form.save()
self.object = ratingForm.save()
self.object.status = constants.KRA_CLOSED_STATUS
self.object.save()
messages.success(self.request, "KRA Assessment completed successfully")
NotificationManager.kra_update_notification(request, self.object)
return redirect(self.get_success_url())
else:
return self.render_to_response(self.get_context_data(form=form, ratingForm=ratingForm))
def update(self, request, *args, **kwargs):
partial = kwargs.pop('partial', False)
instance = self.get_object()
serializer = self.get_serializer(instance,
data=request.data,
partial=partial)
if serializer.is_valid():
kra = self.perform_update(serializer)
NotificationManager.kra_update_notification(self.request, kra)
return Response(
utils.build_response(True, None,
KraSerializer(kra).data))
return Response(utils.build_response(False, None, serializer.errors))
def form_valid(self, form):
cd = form.cleaned_data
try:
bucket = form.save(commit=False)
bucket.created_by = self.request.user
bucket.company = self.request.user.profile.company
bucket.save()
self.object = bucket
messages.success(self.request, "KRA bucket for year '%s' created successfully" % cd['year'])
NotificationManager.bucket_update_notification(self.request, bucket)
return HttpResponseRedirect(self.get_success_url())
except IntegrityError:
form.add_error("year", "Sorry, your company already have a KRA bucket for year '%s'" % cd['year'])
return self.render_to_response(self.get_context_data(form=form))
def get(self, request, *args, **kwargs):
bucket = get_object_or_404(KraBucket, reference=kwargs.get("reference"))
if "assessment" in request.GET:
bucket.allow_final_assessment = not bucket.allow_final_assessment
elif "self-assessment" in request.GET:
bucket.allow_self_assessment = not bucket.allow_self_assessment
else:
if bucket.status == constants.KRA_BUCKET_CLOSED_STATUS:
bucket.status = constants.KRA_BUCKET_OPEN_STATUS
else:
bucket.status = constants.KRA_BUCKET_CLOSED_STATUS
bucket.updated_by = request.user
bucket.save()
NotificationManager.bucket_update_notification(request, bucket)
messages.success(request, "KRA Bucket updated successfully")
return super(KRABucketToggle, self).get(request, *args, **kwargs)
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
if serializer.is_valid():
validated_data = serializer.validated_data
kra = self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
message = "KRA setting saved as draft"
if not validated_data.get("is_draft", False):
message = "KRA setting submitted for assessment"
if self.request.user.profile.manager:
NotificationManager.kra_setting_notification(
self.request, kra)
return Response(utils.build_response(True, message,
serializer.data),
headers=headers)
return Response(utils.build_response(False, None, serializer.errors))
def update_task(request, reference):
task = get_object_or_404(
Task,
Q(created_by=request.user.profile,
reference=reference,
status__iexact="pending") | Q(assigned_to=request.user.profile,
reference=reference,
status__iexact="pending"))
status = request.GET.get("status", None)
if status is None or status.title() not in ["Cancelled", "Completed"]:
raise Http404()
task.status = status.title()
if task.status == "Completed":
task.date_completed = datetime.datetime.now()
task.save()
if task.assigned_to:
NotificationManager.task_update_notification(request, task)
return JsonResponse({"message": "Task %s successfully" % status.lower()})
def update(self, request, *args, **kwargs):
partial = kwargs.pop('partial', False)
instance = self.get_object()
serializer = self.get_serializer(instance,
data=request.data,
partial=partial)
if serializer.is_valid():
validated_data = serializer.validated_data
kra = self.perform_update(serializer)
message = "KRA setting saved as draft"
if not validated_data.get("is_draft", False):
message = "KRA setting submitted for assessment"
if self.request.user.profile.manager:
NotificationManager.kra_setting_notification(
self.request, kra)
return Response(
utils.build_response(True, message,
KraSerializer(kra).data))
return Response(utils.build_response(False, None, serializer.errors))
def form_valid(self, form):
try:
if self.kra:
bucket = self.kra.bucket
else:
bucket = KraBucket.objects.get(reference=self.request.GET.get("bucket"),
company=self.request.user.profile.company,
status=constants.KRA_BUCKET_OPEN_STATUS)
# , kras__user = self.request.user,
# kras__is_accepted = True
has_kra_already = False
if self.kra is None:
try:
has_kra_already = bucket.kras.filter(user=self.request.user, status__in=[constants.KRA_OPEN_STATUS,
constants.KRA_LOCKED_STATUS,
constants.KRA_CLOSED_STATUS], is_draft=False).exists()
except:
has_kra_already = False
if has_kra_already:
form._non_form_errors = form.error_class(["Sorry, you already have a KRA setting for '"+bucket.title+"'"])
return self.form_invalid(form)
if self.kra is None:
self.object = Kra.objects.create(user=self.request.user, bucket=bucket,
is_draft=self.request.POST.get("action", "submit").lower() != "submit",
status=constants.KRA_OPEN_STATUS if self.request.POST.get("action", "submit").lower() != "submit" else constants.KRA_LOCKED_STATUS)
form.instance = self.object
else:
self.object = self.kra
self.object.status = constants.KRA_OPEN_STATUS if self.request.POST.get("action", "submit").lower() != "submit" else constants.KRA_LOCKED_STATUS
self.object.is_draft = self.request.POST.get("action", "submit").lower() != "submit"
self.object.save()
form.save()
if self.object.is_draft:
messages.success(self.request, "KRA setting saved as draft")
else:
if self.request.user.profile.manager:
NotificationManager.kra_setting_notification(self.request, self.object)
messages.success(self.request, "KRA setting submitted for assessment")
return HttpResponseRedirect(self.get_success_url())
except KraBucket.DoesNotExist:
form._non_form_errors = form.error_class(["Sorry, the KRA bucket could not be found"])
return self.form_invalid(form)
def post(self, request, *args, **kwargs):
self.object = self.get_object()
self.new_messages.update(read=True)
kra = self.object
resp = {"error": True, "message": "Unexpected data"}
if "message" in request.GET:
form = MessageForm(request.POST, files=request.FILES)
if form.is_valid():
message = form.save(commit=False)
message.kra = kra
message.user = request.user
if form.cleaned_data.get("file"):
message.file_type = form.cleaned_data.get("file").content_type
message.filename = form.cleaned_data.get("file").name
message.save()
msgs = kra.messages.filter(pk__gte=message.pk)
resp = {"success": True,
"messages": render_to_string("kra/messages.html", {"messages": msgs, "user": request.user})}
elif "modify" in request.GET:
kra.status = constants.KRA_OPEN_STATUS
kra.save()
resp = {"success": True, "message": "KRA setting has been opened for modifications successfully"}
elif "reject" in request.GET:
kra.status = constants.KRA_REJECTED_STATUS
kra.save()
resp = {"success": True, "message": "KRA setting has been rejected successfully"}
elif "accept" in request.GET:
kra.is_accepted = True
kra.save()
resp = {"success": True, "message": "KRA setting has been accepted successfully"}
else:
if (self.object.hod_rating and not (self.is_hod or request.user.profile.is_ceo)) or (self.object.hod_rating and not request.user.profile.is_ceo):
raise Http404()
ratingForm = HODRatingForm(self.request.POST or None, instance=self.object, company=self.request.user.profile.company)
if ratingForm.is_valid():
ratingForm.save()
messages.success(request, "Rating updated successfully")
return HttpResponseRedirect(request.META["HTTP_REFERER"])
return self.render_to_response(self.get_context_data(ratingForm=ratingForm))
if not kra.is_draft:
NotificationManager.kra_update_notification(request, kra)
return JsonResponse(resp)
def form_valid(self, form):
issuesForm = self.get_issues_form()
expectationsForm = self.get_expectations_form()
if issuesForm.is_valid() and expectationsForm.is_valid():
with transaction.atomic():
pip = form.save(commit=False)
pip.staff = self.member.user
pip.line_manager = self.request.user
pip.save()
self.object = pip
issuesForm.instance = pip
expectationsForm.instance = pip
issuesForm.save()
expectationsForm.save()
messages.success(self.request, "PIP created successfully")
NotificationManager.pip_notification(self.request,
self.member.user, pip)
return HttpResponseRedirect(self.get_success_url())
return self.form_invalid(form=form,
issuesForm=issuesForm,
expectationsForm=expectationsForm)