376 lines
12 KiB
JavaScript
376 lines
12 KiB
JavaScript
/**
|
|
* @swagger
|
|
* /api/file/generatepdf:
|
|
* post:
|
|
* tags: [Azure Storage]
|
|
* summary: Phase 2
|
|
* description: Create reps pdf from text field
|
|
* consumes:
|
|
* - application/json
|
|
* requestBody:
|
|
* name: PDF
|
|
* description: PDF content body
|
|
* required: true
|
|
* content:
|
|
* 'application/json':
|
|
* schema:
|
|
* type: object
|
|
* properties:
|
|
* representationType:
|
|
* type: string
|
|
* example: "Questionnaire"
|
|
* representationQuestion1:
|
|
* type: string
|
|
* example: "question 111111"
|
|
* representationQuestion2:
|
|
* type: string
|
|
* example: "question 232222"
|
|
* representationCapacity:
|
|
* type: string
|
|
* example: "yes"
|
|
* representationDocuments:
|
|
* type: array
|
|
* example: [{}]
|
|
* pinswg_name:
|
|
* type: string
|
|
* example: "2023-8-24-1692882853853--REP_Bond"
|
|
* containerID:
|
|
* type: string
|
|
* example: "cljzkgyev0006f9tl4pk6u171"
|
|
* appealType:
|
|
* type: integer
|
|
* example: 846040000
|
|
* incidentID:
|
|
* type: string
|
|
* example: "50b533aa-43f1-ec11-aade-00224800be9c"
|
|
* caseRef:
|
|
* type: string
|
|
* example: "CAS-00764-L0Q9W2"
|
|
* parameters:
|
|
* - name: container
|
|
* in: query
|
|
* required: true
|
|
* example: cljzkgyev0006f9tl4pk6u171
|
|
* schema:
|
|
* type: string
|
|
* - name: casefolderID
|
|
* in: query
|
|
* required: true
|
|
* example: CAS-00764-L0Q9W2
|
|
* schema:
|
|
* type: string
|
|
* - name: hash
|
|
* in: query
|
|
* required: true
|
|
* example: 530b67db992ea277a236790be05b2e49bdd9dd02e6d790cc1c25f96cf39687cb
|
|
* schema:
|
|
* type: string
|
|
|
|
*
|
|
* responses:
|
|
* 200:
|
|
* description: Success
|
|
*/
|
|
|
|
import {
|
|
createContainer,
|
|
getContainers,
|
|
getBlobs,
|
|
createRepBlob,
|
|
uploadFile,
|
|
uploadPDFRepFiles,
|
|
createRepPDFBlob
|
|
} from "../../../actions/azurestorage";
|
|
import { hashAPIPath } from "../../../actions/core/hash";
|
|
|
|
import ReactPDF, {
|
|
Document,
|
|
Page,
|
|
Text,
|
|
View,
|
|
StyleSheet,
|
|
PDFViewer
|
|
} from "@react-pdf/renderer";
|
|
import middleware from "../middleware/middleware";
|
|
import nextConnect from "next-connect";
|
|
import fs from "fs";
|
|
import { EnforcementQuestionnaire_pdf } from "../../../components/pdftemplates/enforcement_pdf";
|
|
import { lpaQuestionnaire_pdf } from "../../../components/pdftemplates/lpaQuestionnaire_pdf";
|
|
import { finalComments_pdf } from "../../../components/pdftemplates/finalComments_pdf";
|
|
import { statement_pdf } from "../../../components/pdftemplates/statement_pdf";
|
|
import { writtenStatement_pdf } from "../../../components/pdftemplates/writtenStatement_pdf";
|
|
import { other_pdf } from "../../../components/pdftemplates/other_pdf";
|
|
import { consoleLogger } from "../../../actions/core/logger";
|
|
import { respondError, respondSuccess } from "../middleware/apiResponse";
|
|
//const ApiProxy = nextConnect();
|
|
// ApiProxy.use(middleware);
|
|
|
|
// ApiProxy.post(async (req, res) => {
|
|
|
|
export default async function handler(req, res) {
|
|
const shouldDownload = req.query.download === "true";
|
|
const checkHash = req.query.hash;
|
|
let reqBodyobj =
|
|
typeof req.body === "string" ? JSON.parse(req.body) : req.body;
|
|
|
|
const cleanFilesList = (blobList) => {
|
|
let newblobList = Array.isArray(blobList?.filesList)
|
|
? blobList.filesList
|
|
: [];
|
|
function removeNullObjects(arr) {
|
|
if (!Array.isArray(arr) || arr.length === 0) {
|
|
return arr;
|
|
}
|
|
return arr.filter((obj) => obj !== null);
|
|
}
|
|
|
|
function removeObjectsWithUndefinedKey(arr, key) {
|
|
if (!Array.isArray(arr) || arr.length === 0) {
|
|
return arr;
|
|
}
|
|
return arr.filter((obj) => obj[key] !== undefined);
|
|
}
|
|
|
|
function removeEmptyObjects(arr) {
|
|
if (!Array.isArray(arr) || arr.length === 0) {
|
|
return arr;
|
|
}
|
|
return arr.filter(
|
|
(obj) =>
|
|
obj &&
|
|
typeof obj === "object" &&
|
|
Object.keys(obj).length > 0
|
|
);
|
|
}
|
|
|
|
newblobList = removeEmptyObjects(newblobList);
|
|
newblobList = removeObjectsWithUndefinedKey(newblobList, "name");
|
|
newblobList = removeNullObjects(newblobList);
|
|
|
|
Object.assign(blobList, {
|
|
"filesList": newblobList
|
|
});
|
|
|
|
return blobList;
|
|
};
|
|
|
|
reqBodyobj = reqBodyobj?.hasOwnProperty("filesList")
|
|
? cleanFilesList(reqBodyobj)
|
|
: reqBodyobj;
|
|
|
|
// console.log(
|
|
// "//////////////////////\nreqBodyobj" +
|
|
// req +
|
|
// "\n//////////////////////\n"
|
|
// );
|
|
// console.log(
|
|
// "//////////////////////\nreqBodyobj" +
|
|
// JSON.stringify(req.body) +
|
|
// "\n//////////////////////\n"
|
|
// );
|
|
|
|
const containerID = reqBodyobj.containerID;
|
|
const casefolderID = reqBodyobj.casefolderID;
|
|
const caseRef = reqBodyobj.ticketnumber || reqBodyobj.caseRef;
|
|
const representationType = reqBodyobj.representationType;
|
|
const repRaiser = reqBodyobj.lastname;
|
|
const localeSelect = reqBodyobj.locale;
|
|
//console.log("there are files:", Object.keys(req.files).length);
|
|
|
|
let checkquerypath = "/api/file/generatepdf";
|
|
|
|
if (shouldDownload) {
|
|
checkquerypath += "?download=true";
|
|
}
|
|
|
|
if (typeof checkHash === "undefined" || checkHash.length === 0) {
|
|
return respondError(res, {
|
|
status: 400,
|
|
code: "HASH_REQUIRED",
|
|
message: "hash is required"
|
|
});
|
|
}
|
|
|
|
if (
|
|
hashAPIPath(checkquerypath) !=
|
|
(checkquerypath.indexOf("?") > -1 ? "&hash=" : "?hash=") + checkHash
|
|
) {
|
|
return respondError(res, {
|
|
status: 400,
|
|
code: "INVALID_HASH",
|
|
message: "Invalid hash"
|
|
});
|
|
}
|
|
|
|
//console.log("-------", checkHash);
|
|
//console.log(hashAPIPath(checkquerypath) == "?hash=" + checkHash);
|
|
//console.log(casefolderID, caseRef);
|
|
// Create Document Component
|
|
|
|
const MyDocument = (values) => {
|
|
switch (values.docProps.representationType) {
|
|
case "Questionnaire":
|
|
switch (values.docProps.appealType) {
|
|
case 846040005:
|
|
case 846040006:
|
|
case 846040007:
|
|
return EnforcementQuestionnaire_pdf(
|
|
values,
|
|
values.docProps.locale
|
|
);
|
|
default:
|
|
return lpaQuestionnaire_pdf(
|
|
values,
|
|
values.docProps.locale
|
|
);
|
|
}
|
|
|
|
return lpaQuestionnaire_pdf(values, values.docProps.locale);
|
|
break;
|
|
case "Final comments":
|
|
return finalComments_pdf(values, values.docProps.locale);
|
|
break;
|
|
case "Statement":
|
|
return statement_pdf(values, values.docProps.locale);
|
|
break;
|
|
case "Written statement":
|
|
return writtenStatement_pdf(values, values.docProps.locale);
|
|
break;
|
|
case "Impact":
|
|
return statement_pdf(values, values.docProps.locale);
|
|
break;
|
|
case "Other":
|
|
return other_pdf(values, values.docProps.locale);
|
|
break;
|
|
default:
|
|
return other_pdf(values, values.docProps.locale);
|
|
}
|
|
};
|
|
|
|
let repCapacity = "";
|
|
switch (reqBodyobj.representationCapacity) {
|
|
case "Appellant":
|
|
repCapacity = "APP";
|
|
break;
|
|
case "Agent":
|
|
repCapacity = "AGENT";
|
|
break;
|
|
case "Interested Party/Person":
|
|
repCapacity = "IP";
|
|
break;
|
|
case "Land Owner":
|
|
repCapacity = "LO";
|
|
break;
|
|
case "lpa":
|
|
case "LPA":
|
|
repCapacity = "LPA";
|
|
break;
|
|
|
|
default:
|
|
// code block
|
|
}
|
|
|
|
let repType = "";
|
|
switch (reqBodyobj.representationType) {
|
|
case "Statement":
|
|
repType = "Statement";
|
|
break;
|
|
case "Statement of common ground":
|
|
repType = "SCG";
|
|
break;
|
|
case "Written statement":
|
|
repType = "WS";
|
|
break;
|
|
case "Written statement of evidence":
|
|
repType = "WSE";
|
|
break;
|
|
case "Questionnaire":
|
|
repType = "Questionnaire";
|
|
break;
|
|
case "Final comments":
|
|
repType = "Comments";
|
|
break;
|
|
case "Local Impact Report":
|
|
repType = "Impact";
|
|
break;
|
|
case "Consultation Response":
|
|
repType = "Consultation_Response";
|
|
break;
|
|
case "Marine Impact Report":
|
|
repType = "Marine_Impact";
|
|
break;
|
|
|
|
case "Other":
|
|
repType = "OTHER";
|
|
break;
|
|
|
|
default:
|
|
// code block
|
|
}
|
|
|
|
//console.log(
|
|
// "///////////////////////////////////\n file created: \n" +
|
|
// process.cwd() +
|
|
// `tmp/${reqBodyobj.repfile_name}.pdf` +
|
|
// "\n folder:" +
|
|
// process.cwd() +
|
|
// "\n/////////////////////////"
|
|
// );
|
|
|
|
// umcomment to render pdf locally
|
|
// ReactPDF.render(
|
|
// <MyDocument docProps={reqBodyobj} />,
|
|
// process.cwd() + `/tmp/${reqBodyobj.repfile_name}.pdf`
|
|
// );
|
|
|
|
const streamToBuffer = async (readableStream) => {
|
|
return new Promise((resolve, reject) => {
|
|
const chunks = [];
|
|
readableStream.on("data", (chunk) => {
|
|
chunks.push(
|
|
Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
|
|
);
|
|
});
|
|
readableStream.on("end", () => resolve(Buffer.concat(chunks)));
|
|
readableStream.on("error", reject);
|
|
});
|
|
};
|
|
|
|
try {
|
|
const renderedPDFStream = await ReactPDF.renderToStream(
|
|
React.createElement(MyDocument, { docProps: reqBodyobj })
|
|
);
|
|
const renderedPDFBuffer = await streamToBuffer(renderedPDFStream);
|
|
|
|
const data = await createRepPDFBlob(
|
|
renderedPDFBuffer,
|
|
containerID,
|
|
caseRef,
|
|
reqBodyobj.repfile_name
|
|
);
|
|
|
|
if (shouldDownload) {
|
|
const filename = `${reqBodyobj.repfile_name || "questionnaire"}.pdf`;
|
|
res.setHeader("Content-Type", "application/pdf");
|
|
res.setHeader(
|
|
"Content-Disposition",
|
|
`attachment; filename="${filename}"`
|
|
);
|
|
return res.status(200).send(renderedPDFBuffer);
|
|
}
|
|
|
|
return respondSuccess(res, {
|
|
status: "success",
|
|
data: data,
|
|
path: `${caseRef}/${reqBodyobj.repfile_name}/files/${reqBodyobj.repfile_name}.pdf`
|
|
});
|
|
} catch (error) {
|
|
consoleLogger(error);
|
|
return respondError(res, {
|
|
status: 400,
|
|
code: "GENERATE_PDF_FAILED",
|
|
message: "Failed to generate PDF"
|
|
});
|
|
}
|
|
}
|