def put(self, request, pk, format=None):
uid = request.user.id
body = request.data
if not body:
return HttpResponseBadRequest("Missing request body")
app = get_application_for_user(pk, uid)
if not app:
return HttpResponseNotFound("No record found")
(steps_key_id, steps_enc) = self.encrypt_steps(body["steps"])
app.last_updated = timezone.now()
app.app_type = body.get("type")
app.current_step = body.get("currentStep")
app.steps = steps_enc
app.user_type = body.get("userType")
app.applicant_name = body.get("applicantName")
app.user_name = body.get("userName")
app.respondent_name = body.get("respondentName")
app.protected_party_name = body.get("protectedPartyName")
app.protected_child_name = body.get("protectedChildName")
app.application_location = body.get("applicationLocation")
app.save()
return Response("success")
def put(self, request, pk, format=None):
uid = request.user.id
body = request.data
if not body:
return HttpResponseBadRequest("Missing request body")
app = get_application_for_user(pk, uid)
if not app:
return HttpResponseNotFound("No record found")
(steps_key_id, steps_enc) = self.encrypt_steps(body["steps"])
app.last_updated = timezone.now()
app.app_type = body.get("type")
app.current_step = body.get("currentStep")
app.steps = steps_enc
app.user_type = body.get("userType")
app.applicant_name = body.get("applicantName")
app.user_name = body.get("userName")
app.deceased_name = body.get("deceasedName")
app.deceased_date_of_death = body.get("deceasedDateOfDeath")
app.date_of_will = body.get("dateOfWill")
app.application_location = body.get("applicationLocation")
app.save()
return Response("success")
def get(self, request, pk, format=None):
uid = request.user.id
application = get_application_for_user(pk, uid)
steps_dec = settings.ENCRYPTOR.decrypt(application.key_id, application.steps)
steps = json.loads(steps_dec)
submission = EFilingSubmission.objects.filter(
id=application.last_efiling_submission_id
).first()
data = {"id": application.id,
"type": application.app_type,
"steps": steps,
"lastUpdate": application.last_updated,
"lastPrinted": application.last_printed,
"currentStep": application.current_step,
"allCompleted": application.all_completed,
"userType": application.user_type,
"userName": application.user_name,
"userId": application.user_id,
"applicantName": application.applicant_name,
"respondentName": application.respondent_name,
"protectedPartyName": application.protected_party_name,
"protectedChildName": application.protected_child_name,
"applicationLocation": application.application_location,
"packageNumber": submission.package_number if submission is not None else "",
"packageUrl": submission.package_url if submission is not None else "",
"lastFiled": application.last_filed}
return Response(data)
def post(self, request, application_id):
documents_string = request.POST.get("documents")
request_files = request.FILES.getlist("files")
# Validations.
validations_errors = self._get_validation_errors(
request_files, documents_string)
if validations_errors:
return validations_errors
application = get_application_for_user(application_id, request.user.id)
if application.prepared_pdf_id is None:
return JsonMessageResponse("PO PDF is not generated.", status=400)
# Data conversion.
incoming_documents = json.loads(documents_string)
po_pdf_content, po_json = get_protection_order_content(application)
outgoing_documents = self._process_incoming_files_and_documents(
po_pdf_content, po_json, incoming_documents, request_files)
del request_files
data = self.efiling_parsing.convert_data_for_efiling(
request, application, outgoing_documents)
# EFiling upload document.
transaction_id = str(uuid.uuid4())
efiling_submission = EFilingSubmissionModel(
transaction_id=transaction_id,
application_id=application.id,
)
efiling_submission.save()
outgoing_files = convert_document_to_multi_part(outgoing_documents)
del outgoing_documents
upload_result = self.efiling_submission.upload_documents(
request.user.universal_id, transaction_id, outgoing_files)
if upload_result is None or "submissionId" not in upload_result:
message = (upload_result["message"]
if upload_result and "message" in upload_result else
"Document Upload Failed.")
return JsonMessageResponse(message, status=500)
# EFiling package submission.
submission_id = upload_result["submissionId"]
redirect_url, message = self.efiling_submission.generate_efiling_url(
request.user.universal_id, transaction_id, submission_id, data)
if redirect_url is not None:
efiling_submission.submission_id = submission_id
efiling_submission.last_updated = timezone.now()
efiling_submission.save()
application.last_efiling_submission_id = efiling_submission.id
application.save()
return JsonResponse({
"redirectUrl": redirect_url,
"message": message
})
return JsonMessageResponse(message, status=500)
def get(self, request, pk, format=None):
uid = request.user.id
application = get_application_for_user(pk, uid)
steps_dec = settings.ENCRYPTOR.decrypt(application.key_id,
application.steps)
steps = json.loads(steps_dec)
data = {
"id": application.id,
"type": application.app_type,
"steps": steps,
"lastUpdate": application.last_updated,
"lastFiled": application.last_filed,
"lastPrinted": application.last_printed,
"currentStep": application.current_step,
"allCompleted": application.all_completed,
"userType": application.user_type,
"userName": application.user_name,
"userId": application.user_id,
"applicantName": application.applicant_name,
"deceasedName": application.deceased_name,
"deceasedDateOfDeath": application.deceased_date_of_death,
"dateOfWill": application.date_of_will,
"applicationLocation": application.application_location
}
return Response(data)
def put(self, request, application_id):
body = request.data
application = get_application_for_user(application_id, request.user.id)
efiling_submission = EFilingSubmissionModel.objects.filter(
id=application.last_efiling_submission_id).first()
if not efiling_submission:
return HttpResponse(status=404)
efiling_submission.package_number = body.get("packageNumber")
efiling_submission.package_url = body.get("packageUrl")
efiling_submission.last_updated = timezone.now()
efiling_submission.save()
application.last_filed = timezone.now()
application.save()
return HttpResponse(status=204)
def post(self, request, application_id):
html = request.data['html']
json_data = request.data['json_data']
user_id = request.user.id
app = get_application_for_user(application_id, user_id)
if not app:
return HttpResponseNotFound(no_record_found)
name = request.query_params.get("name")
pdf_type = request.query_params.get("pdf_type")
version = request.query_params.get("version")
if None in [name, pdf_type, version]:
return HttpResponseBadRequest("Missing parameters.")
try:
pdf_result = self.get_pdf_by_application_id_and_type(
application_id, pdf_type)
pdf_content = self.generate_pdf(name, html)
(pdf_key_id,
pdf_content_enc) = settings.ENCRYPTOR.encrypt(pdf_content)
(pdf_key_id, json_enc) = settings.ENCRYPTOR.encrypt(
json.dumps(json_data).encode("utf-8"))
if pdf_result:
pdf_result.data = pdf_content_enc
pdf_result.json_data = json_enc
pdf_result.key_id = pdf_key_id
pdf_result.pdf_type = pdf_type
pdf_result.version = version
else:
pdf_result = PreparedPdf(
application_id=application_id,
data=pdf_content_enc,
json_data=json_enc,
key_id=pdf_key_id,
pdf_type=pdf_type,
version=version,
)
pdf_result.save()
app.last_printed = timezone.now()
app.save()
except Exception as ex:
LOGGER.error("ERROR: Pdf generation failed %s", ex)
raise
if request.query_params.get("noDownload"):
return HttpResponse(status=204)
else:
return self.create_download_response(pdf_content)
def get(self, request, application_id):
user_id = request.user.id
app = get_application_for_user(application_id, user_id)
if not app:
return HttpResponseNotFound(no_record_found)
pdf_type = request.query_params.get("pdf_type")
if pdf_type is None:
return HttpResponseBadRequest("Missing parameters.")
prepared_pdf = self.get_pdf_by_application_id_and_type(
application_id, pdf_type)
if prepared_pdf is None:
return HttpResponseNotFound(no_record_found)
pdf_content = settings.ENCRYPTOR.decrypt(prepared_pdf.key_id,
prepared_pdf.data)
return self.create_download_response(pdf_content)
def post(self, request, pk, name=None):
data = request.data
uid = request.user.id
app = get_application_for_user(pk, uid)
if not app:
return HttpResponseNotFound("No record found")
name = request.query_params.get("name")
try:
pdf_result = self.get_pdf(pk)
if not pdf_result:
pdf_content = self.generate_pdf(name, data)
(pdf_key_id,
pdf_content_enc) = settings.ENCRYPTOR.encrypt(pdf_content)
(pdf_key_id, json_enc) = settings.ENCRYPTOR.encrypt(
json.dumps(data).encode("utf-8"))
pdf_response = PreparedPdf(data=pdf_content_enc,
json_data=json_enc,
key_id=pdf_key_id)
pdf_response.save()
app.prepared_pdf_id = pdf_response.pk
elif app.last_printed is None or app.last_updated > app.last_printed:
pdf_queryset = PreparedPdf.objects.filter(id=pdf_result.id)
pdf_content = self.generate_pdf(name, data)
(pdf_key_id,
pdf_content_enc) = settings.ENCRYPTOR.encrypt(pdf_content)
(pdf_key_id, json_enc) = settings.ENCRYPTOR.encrypt(
json.dumps(data).encode("utf-8"))
pdf_queryset.update(data=pdf_content_enc)
pdf_queryset.update(json_data=json_enc)
pdf_queryset.update(created_date=timezone.now())
else:
pdf_content = settings.ENCRYPTOR.decrypt(
pdf_result.key_id, pdf_result.data)
app.last_printed = timezone.now()
app.save()
except Exception as ex:
LOGGER.error("ERROR: Pdf generation failed %s", ex)
raise
if request.query_params.get("noDownload"):
return HttpResponse(status=204)
else:
response = HttpResponse(content_type="application/pdf")
response[
"Content-Disposition"] = 'attachment; filename="report.pdf"'
response.write(pdf_content)
return response
def get(self, request: Request, pk):
forms = ["FormP1", "FormP9"]
uid = request.user.id
application = get_application_for_user(pk, uid)
stats = {"ID": application.id}
for form in forms:
try:
px = PreparedPdf.objects.get(application_id=application.id,
pdf_type=form)
except:
px = False
stats.update({
f"{form}":
"Yes" if px else "No",
f"{form} Created Date":
px.created_date if px else None,
f"{form} Last Updated":
px.last_updated if px and px.last_updated else None,
})
return Response(stats)
def delete(self, request, pk, format=None):
uid = request.user.id
application = get_application_for_user(pk, uid)
application.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def post(self, request, application_id):
html = request.data["html"]
json_data = request.data["json_data"]
user_id = request.user.id
app = get_application_for_user(application_id, user_id)
if not app:
return HttpResponseNotFound(no_record_found)
pdf_type = request.query_params.get("pdf_type")
version = request.query_params.get("version")
if None in [pdf_type, version]:
return HttpResponseBadRequest("Missing parameters.")
try:
pdf_result = self.get_pdf_by_application_id_and_type(
application_id, pdf_type)
pdf_content = self.generate_pdf(html)
(pdf_key_id,
pdf_content_enc) = settings.ENCRYPTOR.encrypt(pdf_content)
(pdf_key_id, json_enc) = settings.ENCRYPTOR.encrypt(
json.dumps(json_data).encode("utf-8"))
if pdf_result:
pdf_result.data = pdf_content_enc
pdf_result.json_data = json_enc
pdf_result.key_id = pdf_key_id
pdf_result.pdf_type = pdf_type
pdf_result.version = version
pdf_result.last_updated = timezone.now()
else:
pdf_result = PreparedPdf(
application_id=application_id,
data=pdf_content_enc,
json_data=json_enc,
key_id=pdf_key_id,
pdf_type=pdf_type,
version=version,
)
pdf_result.save()
app.last_printed = timezone.now()
app.save()
except Exception as ex:
LOGGER.error("ERROR: Pdf generation failed %s", ex)
raise
appended_form = request.data.get("appended_form", None)
if appended_form:
pdf_merger = PdfFileMerger()
merged_forms = BytesIO()
pdf_merger.append(PdfFileReader(stream=BytesIO(pdf_content)))
pdf_merger.append(
PdfFileReader(
stream=BytesIO(self.generate_pdf(appended_form))))
pdf_merger.write(merged_forms)
merged_forms.seek(0)
pdf_content = merged_forms.read()
pdf_merger.close()
if request.query_params.get("noDownload"):
return HttpResponse(status=204)
else:
return self.create_download_response(pdf_content)
