DockerERTFF/public/js/libProcessScript.js

// JavaScript Document
// Replaces libPDFscripts.js
// NEW - Process Scripts
// 
//  ** OFFICIAL SCRIPT TO USE WHEN IN PRODUCTION
//

// Utility to fetch PDF bytes


console.log("LIBRARY: libProcessScript.js")

//const path = FileSystemHandle.require('node:path')

let showLog = true;
const dd = createDebugLogger(showLog, "dd"); // code function at bottom of the page



// Wrapper function to fetch, update, and download PDF
async function processAndDownloadPdf(filePath, ...dataSources) {
    try {
        const pdfBytes = await fetchPdfBytes(filePath);
        const updatedPdfBytes = await updatePdfFields(pdfBytes, dataSources);
        const fileName = generateRandomFilename(8, "ERT_", ".pdf");
        //const saveFilePath = await savePdfToFile(pdfBytes);
        //dd("[PDF PATH]", saveFilePath);
        downloadPdf(updatedPdfBytes, fileName);
    } catch (err) {
        dd("Error Processing PDF", err)
        //console.error("Error processing the PDF:", err);
    }
}




async function fetchPdfBytes(filePath) {
    dd(filePath);

    try {
        const response = await fetch(filePath);
        if (!response.ok) throw new Error(`Failed to fetch PDF from ${filePath}`);
        return await response.arrayBuffer();
    } catch (err) {
        console.error("Error fetching PDF bytes:", err);
        throw err;
    }
}

// Update form fields in the PDF
async function updatePdfFields(
    pdfBytes,
    dataSources,
    skipMissingFields = true
) {
    try {
        const pdfDoc = await PDFLib.PDFDocument.load(pdfBytes);
        const form = pdfDoc.getForm();

        dataSources.forEach((dataSource) => {
            dataSource.forEach((record) => {
                Object.entries(record).forEach(([fieldName, fieldValue]) => {
                    try {
                        const formField = form.getTextField(fieldName);
                        if (formField) {
                            dd(fieldName, "-->", fieldValue);
                            formField.setText(String(fieldValue));
                        } else if (!skipMissingFields) {
                            console.warn(`Field "${fieldName}" not found.`);
                        }
                    } catch (err) {
                        console.error(`Error updating field "${fieldName}":`, err);
                    }
                });
            });
        });

        return await pdfDoc.save();
    } catch (err) {
        console.error("Error updating PDF fields:", err);
        throw err;
    }
}

// Function to trigger download of the updated PDF
function downloadPdf(pdfBytes, fileName) {
    const blob = new Blob([pdfBytes], { type: "application/pdf" });
    const url = URL.createObjectURL(blob);

    const link = Object.assign(document.createElement("a"), {
        href: url,
        download: fileName,
    });

    link.click();
    URL.revokeObjectURL(url); // Clean up the URL immediately
}

function generateRandomFilename(length = 8, prefix = "", suffix = "") {
    const characters =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    const array = Array.from({ length }, () =>
        characters.charAt(Math.floor(Math.random() * characters.length))
    );
    const filename = `${prefix}${array.join("")}${suffix}`;

    dd("Random Filename:", filename);
    return filename;
}

// Example Usage:




async function savePdfToFile(pdfBytes) {
    const randomFilename = generateRandomFilename(12, "", ".pdf");
    File.path;
    const filePath = Filehandle.path.join(__dirname, "PDF", randomFilename);
    dd("[SAVE TO DISK]", randomFilename);
    // Save the file to disk
    await fs.writeFile(filePath, Buffer.from(pdfBytes));

    // Return a URL or file path based on your server setup
    return `/PDF/${randomFilename}`;
}

function createDebugLogger(debug, prefix = "DD") {
    return function (message, ...optionalParams) {

        switch (debug) {
            case true:
                console.log(
                    `[${prefix}]`.toUpperCase(), `${message}`, ...optionalParams);
                break
        }
    };
}

function saveSignature() {
    const canvas = document.getElementById('signatureCanvas');
    const imageData = canvas.toDataURL('image/png');
    dd(imageData.length)
    // Trigger the server action and handle the response
    dmx.parse('serverconnect_sign.load({imageData: "' + imageData + '"})');
    //dmx.parse('serverconnect_sign.load({ image: imageData })');
    /** 
    dmx.parse('serverconnect_sign.load', { image: imageData }).then((response) => {
        //dmx.parse('serverconnect_sign.load({image: "' + imageData + '"})').then((response) => {
        const uploadedSignature = document.getElementById('uploadedSignature');
        uploadedSignature.src = response.fileUrl; // Use the file path returned from the server
        dd(response.fileUrl)
    }).catch((error) => {
        console.error("Error uploading signature:", error);
    });
*/
}


// ************** DUMMY TEST FUNCTIONS BELOW ******************  //

function runMyFunction() {
    //  alert("function run")
    let result = generateRandomIdentifier(9);
    // Use Wappler dmx.set to bind result to a Wappler variable if needed
    //<p>{{myResult}}</p>
    console.log(result)
    dmx.global.set('myResult', result);

}

function generateRandomIdentifier(v) {
    return generateRandomFilename(v)
}