@gov-cy/govcy-express-services 0.1.1

package/src/utils/govcyNotification.mjs

@@ -0,0 +1,85 @@
+import axios from "axios";
+import { logger } from "./govcyLogger.mjs";
+import { getEnvVariable } from "./govcyEnvVariables.mjs";
+import https from 'https';
+
+/**
+ * Utility to send email using the Notifications API
+ * @param {string} subject - Email subject
+ * @param {string} body - Email body content
+ * @param {string[]} recipients - List of recipient email addresses
+ * @param {string} [channel='eMail'] - Channel to use (default: 'eMail')
+ * @param {Array<{ Name: string, Content: string }>} [attachments=[]] - List of attachments (optional)
+ * @param {number} retries - Number of retry attempts (default: 3)
+ * @returns {Promise<object>} - API response
+ */
+export async function sendEmail(subject, body, recipients, channel = "eMail", attachments = [], retries = 3) {
+//     Test	    https://dis.dev.gateway.local/DITS.CeGG.DIS.Notifications/ 
+// Production	https://dis.gateway.local/DITS.CeGG.DIS.Notifications/ 
+//DSF SWAGGER: https://dsf-api-dev.dmrid.gov.cy/index.html
+    const url = getEnvVariable("DSF_API_GTW_NOTIFICATION_API_URL");
+    let attempt = 0;
+
+    const payload = {
+        subject: subject,
+        body: body,
+        channel: channel,
+        recipients: recipients,
+        attachments: attachments,
+    };
+
+    while (attempt < retries) {
+        try {
+            logger.debug(`📤 Sending email (Attempt ${attempt + 1})`, { url, payload });
+
+            const response = await axios.post(url, payload, {
+                timeout: 10000, // 10 seconds timeout
+                headers: {
+                    "Content-Type": "application/json",
+                    "Accept": "text/plain",
+                    "client-key": `${getEnvVariable("DSF_API_GTW_CLIENT_ID")}`,
+                    "dsfgtw-api-key" : `${getEnvVariable("DSF_API_GTW_SECRET")}`,
+                    "service-id": `${getEnvVariable("DSF_API_GTW_SERVICE_ID")}`
+                },
+                httpsAgent: new https.Agent({ rejectUnauthorized: false }) 
+            });
+
+            // Check if the response status is 200
+            if (response.status !== 200) {
+                throw new Error(`Unexpected HTTP status: ${response.status}`);
+            }
+
+            let responseData = response.data;
+
+            // Check if the response data contains the expected structure
+            const { succeeded, errorCode, errorMessage } = responseData;
+            logger.debug(`📥 Received API response data`, { succeeded, errorCode, errorMessage });
+            if (typeof succeeded !== "boolean") {
+                throw new Error("Invalid API response structure: Succeeded must be a boolean");
+            }
+
+            if (!succeeded && typeof errorCode !== "number") {
+                throw new Error("Invalid API response structure: ErrorCode must be a number when Succeeded is false");
+            }
+
+            logger.info(`✅ Email sent successfully`, responseData);
+            return responseData.data; // Return the successful response
+        } catch (error) {
+            attempt++;
+            logger.debug(`🚨 Email sending failed (Attempt ${attempt})`, {
+                message: error.message,
+                status: error.response?.status,
+                data: error.response?.data,
+                error: error
+            });
+
+            if (attempt >= retries) {
+                logger.error(`🚨 Email sending failed after ${retries} attempts`, error.message);
+                throw new Error(error.responseData?.data?.ErrorMessage || "Email sending failed after retries");
+            }
+
+            logger.info(`🔄 Retrying email sending (Attempt ${attempt + 1})...`);
+        }
+    }
+}
+

package/src/utils/govcyPdfMaker.mjs

@@ -0,0 +1,27 @@
+import puppeteer from 'puppeteer';
+
+/**
+ * Generates a PDF from HTML and returns it as a Buffer.
+ * @param {string} html - The full HTML string of the document (should be accessible HTML).
+ * @returns {Promise<Buffer>} - The generated PDF buffer.
+ */
+export async function generatePDF(html) {
+  const browser = await puppeteer.launch({ headless: 'new' });
+  const page = await browser.newPage();
+
+  await page.setContent(html, { waitUntil: 'networkidle0' });
+
+  const pdfUint8Array = await page.pdf({
+    format: 'A4',
+    printBackground: true,
+    displayHeaderFooter: false,
+    preferCSSPageSize: true,
+  });
+
+  await browser.close();
+
+  // Convert Uint8Array to Buffer
+  const pdfBuffer = Buffer.from(pdfUint8Array);
+
+  return pdfBuffer;
+}

package/src/utils/govcyReviewSummary.mjs

@@ -0,0 +1,205 @@
+/**
+ * @module govcyReviewSummary
+ * @fileoverview This module generates a review summary list based on user input.
+ */
+
+import * as govcyResources from "../resources/govcyResources.mjs";
+import * as dataLayer from "./govcyDataLayer.mjs";
+import { ALLOWED_FORM_ELEMENTS } from "./govcyConstants.mjs";
+/**
+ * Generate a review summary list based on the user's input.
+ * 
+ * @param {object} req the request object
+ * @param {string} siteId the site id
+ * @param {object} service the service object
+ * @returns {object} summaryList the summary list object 
+ */
+export function govcyGenerateReviewSummary(req, siteId, service) {
+    // Base summary list structure
+    let summaryList = { element: "summaryList", params: { items: [] } };
+
+    // Define allowed form elements
+    //TODO: Handle textInput
+    const allowedElements = ALLOWED_FORM_ELEMENTS;
+
+    /**
+     * Helper function to retrieve user input from session.
+     * 
+     * @param {string} pageUrl the page url
+     * @param {string} elementName the element name
+     * @returns {string} the session value or an empty string if not found
+     */
+    function getSessionValue(pageUrl, elementName) {
+        return dataLayer.getFormDataValue(req.session, siteId, pageUrl, elementName) || ""; // Use the utility function to get the value
+    }
+
+    /**
+     * Helper function to format the date input.
+     * @param {string} pageUrl the page url
+     * @param {string} elementName the element name
+     * @param {string} lang the language
+     * @returns {string} the formatted date input
+     */
+    function formatDateInput(pageUrl, elementName, lang) {
+        const day = getSessionValue(pageUrl, `${elementName}_day`);
+        const month = getSessionValue(pageUrl, `${elementName}_month`);
+        const year = getSessionValue(pageUrl, `${elementName}_year`);
+
+        if (!day || !month || !year) return "";
+
+        return `${day}/${month}/${year}`; // EU format: DD/MM/YYYY
+    }
+
+    /**
+     * Helper function to get the item value of checkboxes based on the selected value.
+     * @param {object} formElement the form element
+     * @param {sting} value the value 
+     * @param {string} lang the language 
+     * @returns {string} the item value of checkboxes 
+     */
+    function processCheckboxes(formElement, value, lang) {
+        let valueString = "";
+        // Check if the value is an array and process accordingly
+        if (Array.isArray(value)) {
+            value.forEach(selectedValue => {
+                const matchedItem = formElement.params.items.find(item => item.value === selectedValue);
+                if (matchedItem) {
+                    valueString += `${matchedItem.text[lang]}, `;
+                }
+            });
+        // If the value is a string, find the corresponding item
+        } else if (typeof value === "string") {
+            const matchedItem = formElement.params.items.find(item => item.value === value);
+            if (matchedItem) {
+                valueString = matchedItem.text[lang];
+            }
+        }
+        // Remove trailing comma and space
+        return valueString.replace(/,\s*$/, ""); // Remove trailing comma
+    }
+
+    /**
+     * Helper function to get the item value of radios or select based on the selected value. 
+     * @param {object} formElement the form element
+     * @param {string} value the value
+     * @param {string} lang the language
+     * @returns {string} the item value of radios or select
+    */
+    function processRadiosOrSelect(formElement, value, lang) {
+        if (typeof value === "string") {
+            const matchedItem = formElement.params.items.find(item => item.value === value);
+            if (matchedItem) {
+                return matchedItem.text[lang];
+            }
+        }
+        return value;
+    }
+    
+    /**
+     * Helper function to create a summary list item.
+     * @param {object} formElement the form element
+     * @param {string} value the value
+     * @param {string} lang the language
+     * @returns {object} the summary list item
+    */
+    function createSummaryListItem(formElement, value, lang) {
+        return {
+            "key": formElement.params.label || formElement.params.legend || { "en": formElement.params.name, "el": formElement.params.name, "tr": formElement.params.name },
+            "value": [
+                {
+                    "element": "textElement",
+                    "params": {
+                        "text": { "en": value, "el": value, "tr": value},
+                        "type": "span"
+                    }
+                }
+            ]
+        };
+    }
+
+    // Process each page in the service
+    service.pages.forEach(page => {
+        page.pageTemplate.sections.forEach(section => {
+            if (!section.elements) return;
+
+            section.elements.forEach(element => {
+                if (element.element === "form") {
+                    let summaryListInner = { element: "summaryList", params: { items: [] } };
+
+                    element.params.elements.forEach(formElement => {
+                        if (allowedElements.includes(formElement.element)) {
+                            let value = getSessionValue(page.pageData.url, formElement.params.name);
+
+                            // Handle checkboxes
+                            if (formElement.element === "checkboxes" && value.length > 0) {
+                                value = processCheckboxes(formElement, value, req.globalLang);
+                            }
+
+                            // Handle select and radios
+                            if ((formElement.element === "select" || formElement.element === "radios") && typeof value === "string") {
+                                value = processRadiosOrSelect(formElement, value, req.globalLang);
+                            }
+
+                            // Handle date input
+                            if (formElement.element === "dateInput") {
+                                value = formatDateInput(page.pageData.url, formElement.params.name, req.globalLang);
+                            }
+
+                            // Add to summary list
+                            summaryListInner.params.items.push(createSummaryListItem(formElement, value, req.globalLang));
+                        }
+
+                        // Handle conditional elements inside radios
+                        if (formElement.element === "radios") {
+                            let selectedRadioValue = getSessionValue(page.pageData.url, formElement.params.name);
+
+                            formElement.params.items.forEach(item => {
+                                if (item.conditionalElements && selectedRadioValue === item.value) { // ✅ New: Only process matching radio option
+                                    item.conditionalElements.forEach(conditionalElement => {
+                                        if (allowedElements.includes(conditionalElement.element)) {
+                                            let value = getSessionValue(page.pageData.url, conditionalElement.params.name);
+
+                                            // Handle checkboxes
+                                            if (conditionalElement.element === "checkboxes" && value.length > 0) {
+                                                value = processCheckboxes(conditionalElement, value, req.globalLang);
+                                            }
+
+                                            // Handle select and radios
+                                            if ((conditionalElement.element === "select" || conditionalElement.element === "radios") && typeof value === "string") {
+                                                value = processRadiosOrSelect(conditionalElement, value, req.globalLang);
+                                            }
+
+                                            // Handle date input
+                                            if (conditionalElement.element === "dateInput") {
+                                                value = formatDateInput(page.pageData.url, conditionalElement.params.name, req.globalLang);
+                                            }
+
+                                            // Add to summary list
+                                            summaryListInner.params.items.push(createSummaryListItem(conditionalElement, value, req.globalLang));
+                                        }
+                                    });
+                                }
+                            });
+                        }
+                    });
+
+                    // Add inner summary list to the main summary list
+                    summaryList.params.items.push({
+                        "key": page.pageData.title,
+                        "value": [summaryListInner],
+                        "actions": [ //add change link
+                            {
+                                text:govcyResources.staticResources.text.change,
+                                classes: govcyResources.staticResources.other.noPrintClass,
+                                href: govcyResources.constructPageUrl(siteId, page.pageData.url, "review"),
+                                visuallyHiddenText: page.pageData.title
+                            }
+                        ]
+                    });
+                }
+            });
+        });
+    });
+
+    return summaryList;
+}