@gov-cy/govcy-express-services 0.1.1

package/src/middleware/govcyServiceEligibilityHandler.mjs

@@ -0,0 +1,101 @@
+import { govcyApiRequest } from "../utils/govcyApiRequest.mjs";
+import { logger } from "../utils/govcyLogger.mjs";
+import { getEnvVariable } from "../utils/govcyEnvVariables.mjs";
+import { getPageConfigData } from "../utils/govcyLoadConfigData.mjs";
+import { handleMiddlewareError } from "../utils/govcyUtils.mjs";
+import * as dataLayer from "../utils/govcyDataLayer.mjs";
+
+// Helper to show error page or redirect (reuse your review handler logic)
+function handleEligibilityError(res, errorPage,next) {
+    if (errorPage) {
+        return res.redirect(errorPage);
+    }
+    // fallback: show generic error
+    return handleMiddlewareError("Eligibility check failed", 403, next);
+}
+
+export function govcyServiceEligibilityHandler(checkForForm = false) {
+    return async (req, res, next) => {
+        try {
+            const service = req.serviceData;
+            // Extract siteId and pageUrl from request
+            let { siteId, pageUrl } = req.params; 
+            // If `checkForForm` is set, check if page has no form and skip the eligibility check 
+            if (checkForForm) {
+                // 🏠 Handle index page: If pageUrl is undefined (meaning the user accessed `/:siteId`), set a default value or handle accordingly
+                if (!pageUrl) pageUrl = "index";
+                // 🔍 Find the page by pageUrl
+                const page = getPageConfigData(service, pageUrl);
+                if (!page || !page.pageTemplate) return next(); // Defensive: skip if no template
+                // Deep copy pageTemplate to avoid modifying the original
+                const pageTemplateCopy = JSON.parse(JSON.stringify(page.pageTemplate));
+
+                // Check if any section contains a form element
+                const hasForm = pageTemplateCopy.sections?.some(section =>
+                    section.elements?.some(el => el.element === "form")
+                );
+                if (!hasForm) {
+                    // No form found, skip eligibility check
+                    return next();
+                }
+                // else: continue with eligibility check
+            }
+            const eligibilityEndpoints = service?.site?.eligibilityAPIEndpoints || [];
+            const user = dataLayer.getUser(req.session); // Get the user from the session;
+
+            for (const endpoint of eligibilityEndpoints) {
+                // get the API endpoint URL, clientKey, serviceId from the environment variable (handle edge cases)
+                const url = getEnvVariable(endpoint?.url || "", false);
+                const clientKey = getEnvVariable(endpoint?.clientKey || "", false);
+                const serviceId = getEnvVariable(endpoint?.serviceId || "", false);
+                const cashingTimeoutMinutes = endpoint?.cashingTimeoutMinutes ||  0; // Default to 0 if not set
+                if (!url) {
+                    return handleMiddlewareError("🚨 Service eligibility API endpoint URL is missing", 500, next);
+                }
+                if (!clientKey) {
+                    return handleMiddlewareError("🚨 Service eligibility API clientKey is missing", 500, next);
+                }
+                if (!serviceId) {
+                    return handleMiddlewareError("🚨 Service eligibility API serviceId is missing", 500, next);
+                }
+
+                const endpointKey = endpoint?.url || "defaultEndpoint"; 
+                const maxAgeMs = cashingTimeoutMinutes * 60 * 1000; // convert minutes to milliseconds
+                const params = endpoint?.params || {};
+                const method = (endpoint?.method || "GET").toLowerCase();
+                // Check if eligibility result is cached
+                let response = dataLayer.getSiteEligibilityResult(req.session, siteId, endpointKey, maxAgeMs);
+                if (!response) {
+                    // Call the eligibility API
+                    response = await govcyApiRequest(
+                        method,
+                        url,
+                        params, 
+                        true,
+                        user,
+                        { 
+                            accept: "text/plain",       // Set Accept header to text/plain
+                            "client-key": clientKey,    // Set the client key header
+                            "service-id": serviceId,    // Set the service ID header
+                        }
+                    );
+                    // Cache the result
+                    dataLayer.storeSiteEligibilityResult(req.session, siteId, endpointKey, response);
+                }
+
+                // If not eligible, handle error
+                if (!response.Succeeded) {
+                    // Try to find a custom error page for this error code
+                    const errorPage = endpoint.response?.errorResponse?.[String(response.ErrorCode)]?.page;
+                    logger.info(`Eligibility check failed: ${response.ErrorMessage || response.ErrorCode}`);
+                    return handleEligibilityError(res, errorPage, next);
+                }
+            }
+
+            // All checks passed
+            next();
+        } catch (err) {
+            return next(err); // Pass error to govcyHttpErrorHandler
+        }
+    };
+}

package/src/middleware/govcySessionData.mjs

@@ -0,0 +1,9 @@
+/**
+ * Middleware to ensure session storage exists for GovCy data. 
+ */
+export function govcySessionData(req, res, next) {
+    if (!req.session.siteData) {
+        req.session.siteData = {}; // Ensure session storage exists
+    }
+    next();
+}

package/src/middleware/govcySuccessPageHandler.mjs

@@ -0,0 +1,112 @@
+import * as govcyResources from "../resources/govcyResources.mjs";
+import * as dataLayer from "../utils/govcyDataLayer.mjs";
+import { logger } from "../utils/govcyLogger.mjs";
+import { handleMiddlewareError } from "../utils/govcyUtils.mjs";
+import { generateReviewSummary  } from "../utils/govcySubmitData.mjs";
+
+
+/**
+ * Middleware to handle the success page for the service.
+ * This middleware shows the success page.
+ * @param {boolean} isPDF - True if the success page is for a PDF, false otherwise
+ * 
+ */
+export function govcySuccessPageHandler(isPDF = false) {
+    return (req, res, next) => {
+        try {
+            const { siteId } = req.params;
+            
+            // Create a deep copy of the service to avoid modifying the original
+            let serviceCopy = req.serviceData;
+                       
+            // Get the submission data
+            let submissionData = dataLayer.getSiteSubmissionData(req.session, siteId);
+            // ❌ Check if submission data is empty 
+            if (!submissionData || Object.keys(submissionData).length === 0) {
+                return handleMiddlewareError("🚨 Submission data not found.", 404, next);
+            }
+            // Deep copy renderer pageData from
+            let pageData = JSON.parse(JSON.stringify(govcyResources.staticResources.rendererPageData));
+            
+            if (isPDF) {
+                pageData.pageData.mainLayout = "max-width";
+            }
+            // Base page template structure
+            let pageTemplate = {
+                sections: [
+                    // {
+                    //     name: "beforeMain",
+                    //     elements: [govcyResources.staticResources.elements.backLink]
+                    // }
+                ]
+            };
+            // Construct page title
+            const weHaveSendYouAnEmail = {
+                element: "textElement",
+                params: {
+                    type: "p",
+                    text: govcyResources.staticResources.text.weHaveSendYouAnEmail
+                }
+            };
+            
+            // Construct page title
+            const theDataFromYourRequest = {
+                element: "textElement",
+                params: {
+                    type: "p",
+                    text: govcyResources.staticResources.text.theDataFromYourRequest
+                }
+            };
+            // Construct page title
+            const successPanel = {
+                element: "panel",
+                params: {
+                    header: govcyResources.staticResources.text.submissionSuccessTitle,
+                    body: govcyResources.staticResources.text.yourSubmissionId,
+                    referenceNumber: govcyResources.getSameMultilingualObject(serviceCopy.site.languages,submissionData.referenceNumber)
+                }
+            };
+
+            const pdfLink = {
+                element: "htmlElement",
+                params: {
+                    text: govcyResources.getSubmissionPDFLinkHtml(siteId)
+                }   
+            }
+
+            let summaryList = submissionData.renderer_data;
+
+            let mainElements = [];
+            // Add elements to the main section
+            mainElements.push(
+                successPanel,
+                weHaveSendYouAnEmail, 
+                pdfLink,
+                theDataFromYourRequest, 
+                summaryList, 
+                govcyResources.staticResources.elements["govcyFormsJs"]
+            );
+            // Append generated summary list to the page template
+            pageTemplate.sections.push({ name: "main", elements: mainElements });
+            
+            //if user is logged in add he user bane section in the page template
+            if (dataLayer.getUser(req.session)) {
+                pageTemplate.sections.push(govcyResources.userNameSection(dataLayer.getUser(req.session).name)); // Add user name section
+            }
+            
+            //prepare pageData
+            pageData.site = serviceCopy.site;
+            pageData.pageData.title = govcyResources.staticResources.text.submissionSuccessTitle;
+            
+            // Attach processed page data to the request
+            req.processedPage = {
+                pageData: pageData,
+                pageTemplate: pageTemplate
+            };
+            logger.debug("Processed success page data:", req.processedPage, req);
+            next();
+        } catch (error) {
+            return next(error); // Pass error to govcyHttpErrorHandler
+        }
+    };
+}

package/src/public/img/Certificate_A4.svg

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 24.1.2, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 595.276 841.89" enable-background="new 0 0 595.276 841.89" xml:space="preserve">
+<g id="Layer_1">
+	<g>
+		<g>
+			<path fill="#D6D9DC" d="M565.276,30v781.89H30V30H565.276 M595.276,0H0v841.89h595.276V0L595.276,0z"/>
+		</g>
+	</g>
+	<rect x="187.638" y="128.049" fill="#D6D9DC" width="220" height="80"/>
+	<rect x="157.638" y="299.945" fill="#B2B4B6" width="280" height="35"/>
+	<rect x="182.638" y="355.445" fill="#B2B4B6" width="230" height="35"/>
+	<rect x="147.638" y="650.223" fill="#D6D9DC" width="300" height="100"/>
+</g>
+<g id="Layer_2">
+	<g>
+	</g>
+	<g>
+	</g>
+	<g>
+	</g>
+	<g>
+	</g>
+	<g>
+	</g>
+	<g>
+	</g>
+</g>
+</svg>

package/src/public/js/govcyForms.js

@@ -0,0 +1,21 @@
+document.addEventListener("DOMContentLoaded", function () {
+    // --- Show conditionals for checked radios ---
+    document.querySelectorAll('.govcy-radio-input[data-aria-controls]:checked').forEach(radio => {
+        const targetId = radio.getAttribute('data-aria-controls');
+        const targetElement = document.getElementById(targetId);
+
+        if (targetElement) {
+            targetElement.classList.remove('govcy-radio__conditional--hidden');
+        }
+    });
+    // --- Disable submit button after form submission ---
+    document.querySelectorAll('form').forEach(form => {
+        form.addEventListener('submit', function (e) {
+            const submitButton = form.querySelector('[type="submit"]');
+            if (submitButton) {
+                submitButton.disabled = true;
+                submitButton.setAttribute('aria-disabled', 'true');
+            }
+        });
+    });
+});