@gov-cy/govcy-express-services 0.1.1

package/src/middleware/govcyHeadersControl.mjs

@@ -0,0 +1,22 @@
+/**
+ * Middleware to set security and cache control headers for GovCy API responses.
+ * 
+ * @param {object} req The request object
+ * @param {object} res The response object
+ * @param {object} next The next middleware function
+*/
+export function noCacheAndSecurityHeaders(req, res, next) {
+    //set security headers
+    res.set({
+        'X-Content-Type-Options': 'nosniff', //Prevents browsers from MIME-sniffing a response away from the declared Content-Type
+        'X-Frame-Options': 'SAMEORIGIN', //Prevents clickjacking by disallowing the site from being embedded in an <iframe>, unless from the same origin
+        'X-XSS-Protection': '1; mode=block', // Optional - only if you really want to support old IE versions
+        'Content-Security-Policy': "frame-ancestors 'self'", // Modern approach to control what domains are allowed to embed your site in an iframe.
+        'Strict-Transport-Security': 'max-age=31536000; includeSubDomains', // Forces browsers to use HTTPS only, even for future visits.
+        'Referrer-Policy': 'strict-origin-when-cross-origin'
+    });
+    res.set('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0');
+    res.set("Pragma", "no-cache");
+    res.set("Expires", "0");
+    next();
+}

package/src/middleware/govcyHttpErrorHandler.mjs

@@ -0,0 +1,63 @@
+import { govcyFrontendRenderer } from '@gov-cy/govcy-frontend-renderer';
+import * as govcyResources from "../resources/govcyResources.mjs";
+import * as dataLayer from "../utils/govcyDataLayer.mjs";
+import { logger } from "../utils/govcyLogger.mjs";
+
+/**
+ * Middleware function to handle HTTP errors and render appropriate error pages.
+ * This function captures errors that occur during the request lifecycle and generates appropriate error pages based on the error status code.
+ */
+export function govcyHttpErrorHandler(err, req, res, next) {
+
+    logger.debug("HTTP Error details:", err, req); // Log the error details
+    // Set default status and message
+    let statusCode = err.status || 500;
+    let message = err.message || "Internal Server Error";
+
+    // Deep copy renderer pageData from
+    let pageData = JSON.parse(JSON.stringify(govcyResources.staticResources.rendererPageData));
+
+    // Handle specific HTTP errors
+    switch (statusCode) {
+        case 404:
+            logger.info("404 - Page not found.", err.message, req.originalUrl); // Log the error
+            pageData.pageData.title = govcyResources.staticResources.text.errorPage404Title;
+            pageData.pageData.text = govcyResources.staticResources.text.errorPage404Body;
+            message = "404 - Page not found.";
+            break;
+        case 403:
+            logger.warn("HTTP Error:", err.message, req.originalUrl); // Log the error
+            pageData.pageData.title = govcyResources.staticResources.text.errorPage403Title;
+            if (err.message === "Access Denied: natural person policy not met.") {
+                pageData.pageData.text = govcyResources.staticResources.text.errorPage403NaturalOnlyPolicyBody;
+            } else {
+                pageData.pageData.text = govcyResources.staticResources.text.errorPage403Body;
+            }
+            message = "403 - Forbidden access.";
+            break;
+        case 500:
+            logger.error("HTTP Error:", err.message, req.originalUrl); // Log the error
+            pageData.pageData.title = govcyResources.staticResources.text.errorPage500Title;
+            pageData.pageData.text = govcyResources.staticResources.text.errorPage500Body;
+            message = "500 - Something went wrong on our end.";
+            break;
+    }
+
+    res.status(statusCode);
+
+    // Return JSON if the request expects it
+    if (req.headers.accept && req.headers.accept.includes("application/json")) {
+        return res.json({ error: message });
+    }
+
+    // Render an error page for non-JSON requests
+    const renderer = new govcyFrontendRenderer();
+    let pageTemplate = govcyResources.simpleHtmlPageTemplate(pageData.pageData.title, pageData.pageData.text);
+    pageData.site.lang = req.globalLang; //use lang from middleware
+    //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
+    }
+    const html = renderer.renderFromJSON(pageTemplate, pageData);
+    res.send(html);
+}

package/src/middleware/govcyLanguageMiddleware.mjs

@@ -0,0 +1,19 @@
+/**
+ * Middleware to set the language for the GovCy application.
+ * It checks the query parameter and cookie for the language setting. 
+ */
+export function govcyLanguageMiddleware(req, res, next) {
+    let lang = req.query.lang || req.cookies.lang || 'el'; // Default to 'en' if not set
+
+    // let lang = req.query.lang 
+    
+    if (req.query.lang) {
+        res.cookie('lang', lang, { 
+            maxAge: 365 * 24 * 60 * 60 * 1000, 
+            httpOnly: true, 
+            sameSite: 'lax' });
+    }
+
+    req.globalLang = lang; // Store language for request lifecycle
+    next();
+}

package/src/middleware/govcyLogger.mjs

@@ -0,0 +1,15 @@
+import { logger } from '../utils/govcyLogger.mjs';
+
+/**
+ * Middleware to log incoming requests. 
+ */
+export function requestLogger(req, res, next) {
+  const timestamp = new Date().toISOString();
+  logger.info(`[${timestamp}]`, req.method, req.url);
+
+  if (req.session) {
+    logger.info(`Session ID: ${req.sessionID}`);
+  }
+
+  next(); // Pass control to the next middleware
+}

package/src/middleware/govcyManifestHandler.mjs

@@ -0,0 +1,46 @@
+/**
+ * Middleware to handle rendering of manifest.json
+ */
+export function govcyManifestHandler() {
+  return (req, res, next) => {
+    try {
+      const { site } = req.serviceData;
+
+      // Generate the manifest JSON dynamically
+      const manifest = {
+        short_name: site.title[site.lang],
+        name: site.title[site.lang],
+        description: site.description[site.lang],
+        icons: [
+          {
+            src: `${site.cdn.dist}/img/icons-128.png`,
+            type: "image/png",
+            sizes: "128x128"
+          },
+          {
+            src: `${site.cdn.dist}/img/icons-192.png`,
+            type: "image/png",
+            sizes: "192x192"
+          },
+          {
+            src: `${site.cdn.dist}/img/icons-512.png`,
+            type: "image/png",
+            sizes: "512x512"
+          }
+        ],
+        start_url: `/${req.params.siteId}/index`,
+        background_color: "#31576F",
+        display: "standalone",
+        scope: `/${req.params.siteId}/`,
+        theme_color: "#31576F",
+        dir: "ltr"
+      };
+
+      // Set the Content-Type to application/json and send the manifest
+      res.setHeader('Content-Type', 'application/json');
+      res.json(manifest);
+    } catch (error) {
+      return next(error);  // Pass error to govcyHttpErrorHandler
+    }
+  };
+}

package/src/middleware/govcyPDFRender.mjs

@@ -0,0 +1,30 @@
+import { govcyFrontendRenderer } from "@gov-cy/govcy-frontend-renderer";
+import { generatePDF } from "../utils/govcyPdfMaker.mjs";
+
+/**
+ * Middleware function to render PDFs using the GovCy Frontend Renderer.
+ * This function takes the processed page data and template, and generates the final PDF response.
+ */
+export function govcyPDFRender() {
+    return async (req, res) => {
+        try {
+            const renderer = new govcyFrontendRenderer();
+            const { processedPage } = req;
+            const html = renderer.renderFromJSON(processedPage.pageTemplate, processedPage.pageData);
+            let fileName= "govcy.pdf";
+            if (processedPage.fileName) {
+                fileName = `${processedPage.fileName} - ${fileName}`;
+            }
+            const pdfBuffer = await generatePDF(html);
+
+            res.set({
+                'Content-Type': 'application/pdf',
+                'Content-Length': pdfBuffer.length,
+                'Content-Disposition': `attachment; filename="${fileName}"`,
+            });
+            res.send(pdfBuffer);
+        } catch (error) {
+            res.status(500).send('Unable to generate PDF at this time.');
+        }
+    };
+}

package/src/middleware/govcyPageHandler.mjs

@@ -0,0 +1,110 @@
+import { getPageConfigData } from "../utils/govcyLoadConfigData.mjs";
+import { populateFormData } from "../utils/govcyFormHandling.mjs";
+import * as govcyResources from "../resources/govcyResources.mjs";
+import * as dataLayer from "../utils/govcyDataLayer.mjs";
+import { logger } from "../utils/govcyLogger.mjs";
+
+/**
+ * Middleware to handle page rendering and form processing
+ * This middleware processes the page template, populates form data, and shows validation errors.
+ */
+export function govcyPageHandler() {
+  return (req, res, next) => {
+    try {
+      // Extract siteId and pageUrl from request
+      let { siteId, pageUrl } = req.params; 
+      
+      // get service data
+      let serviceCopy = req.serviceData; 
+      
+      // 🏠 Handle index page: If pageUrl is undefined (meaning the user accessed `/:siteId`), set a default value or handle accordingly
+      if (!pageUrl) {
+        logger.debug(`No pageUrl provided for siteId: ${siteId}`, req);
+        // Example: Redirect to a default page or load a homepage
+        pageUrl = "index"; // Change "index" to whatever makes sense for your service
+      }
+
+      // 🔍 Find the page by pageUrl
+      const page = getPageConfigData(serviceCopy, pageUrl);
+
+      // Deep copy pageTemplate to avoid modifying the original
+      const pageTemplateCopy = JSON.parse(JSON.stringify(page.pageTemplate));
+
+      //if user is logged in add he user bane section in the page template
+      if (dataLayer.getUser(req.session)) {
+        pageTemplateCopy.sections.push(govcyResources.userNameSection(dataLayer.getUser(req.session).name)); // Add user name section
+      }
+      //⚙️ Process forms before rendering
+      pageTemplateCopy.sections.forEach(section => {
+        section.elements.forEach(element => {
+          if (element.element === "form") {
+            logger.debug("Processing form element:", element, req);
+            element.params.action = govcyResources.constructPageUrl(siteId, page.pageData.url, (req.query.route === "review" ? "review" : ""));
+            // Set form method to POST
+            element.params.method = "POST";
+            // ➕ Add CSRF token
+            element.params.elements.push(govcyResources.csrfTokenInput(req.csrfToken()));
+            element.params.elements.push(govcyResources.staticResources.elements["govcyFormsJs"]);
+
+            // 🔍 Find the first button with `prototypeNavigate`
+            const button = element.params.elements.find(subElement =>
+              // subElement.element === "button" && subElement.params.prototypeNavigate
+              subElement.element === "button"
+            );
+
+            // ⚙️ Modify the button if it exists
+            if (button) {
+              // Store the value of `prototypeNavigate`
+              //const prototypeNavigateValue = button.params.prototypeNavigate;
+              // Remove `prototypeNavigate`
+              if (button.params.prototypeNavigate) {
+                delete button.params.prototypeNavigate;
+              }
+              // Set `type` to "submit"
+              button.params.type = "submit";
+            }
+
+            // Handle form data
+            let theData = {};
+
+            //--------- Handle Validation Errors ---------
+            // Check if validation errors exist in the session
+            const validationErrors = dataLayer.getPageValidationErrors(req.session, siteId, pageUrl);
+            if (validationErrors ) {
+              // Populate form data from validation errors
+              theData = validationErrors?.formData || {};
+            } else {
+              // Populate form data from session
+              theData = dataLayer.getPageData(req.session, siteId, pageUrl);
+            }
+            //--------- End of Handle Validation Errors ---------
+            
+            populateFormData(element.params.elements, theData,validationErrors);
+            // if there are validation errors, add an error summary
+            if (validationErrors?.errorSummary?.length > 0) {
+              element.params.elements.unshift(govcyResources.errorSummary(validationErrors.errorSummary));
+            }
+            logger.debug("Processed form element:", element, req);
+          }
+        });
+      });
+
+      // Attach processed data to request
+      req.processedPage = {
+        pageData: {
+          "site": serviceCopy.site, 
+          "pageData": {
+            "title": page.pageData.title,
+            "layout": page.pageData.layout,
+            "mainLayout": page.pageData.mainLayout
+          }
+        },
+        pageTemplate: pageTemplateCopy
+      };
+      logger.debug("Processed page data:", req.processedPage, req);
+      next(); // Pass control to the next middleware or route
+    } catch (error) {
+        return next(error);  // Pass error to govcyHttpErrorHandler
+    }
+  };
+}

package/src/middleware/govcyPageRender.mjs

@@ -0,0 +1,14 @@
+import { govcyFrontendRenderer } from "@gov-cy/govcy-frontend-renderer";
+
+/**
+ * Middleware function to render pages using the GovCy Frontend Renderer.
+ * This function takes the processed page data and template, and generates the final HTML response.
+ */
+export function renderGovcyPage() {
+    return (req, res) => {
+        const renderer = new govcyFrontendRenderer();
+        const { processedPage } = req;
+        const html = renderer.renderFromJSON(processedPage.pageTemplate, processedPage.pageData);
+        res.send(html);
+    };
+}

package/src/middleware/govcyRequestTimer.mjs

@@ -0,0 +1,29 @@
+import { logger } from '../utils/govcyLogger.mjs';
+
+/**
+ * Middleware to log the duration of each request.
+ * 
+ * @param {object} req The request object
+ * @param {object} res The response object
+ * @param {function} next The next middleware function
+ */
+export function requestTimer(req, res, next) {
+    // Record the start time of the request
+    req.startTime = Date.now();
+
+    // Listen for the 'finish' event on the response
+    res.on('finish', () => {
+        const duration = Date.now() - req.startTime; // Calculate duration
+        logger.debug('Request completed', {
+            method: req.method,
+            url: req.originalUrl,
+            duration: `${duration}ms`,
+            status: res.statusCode
+        });
+        if (duration > 500) {
+            logger.debug('[WARNING] - Slow request detected',  duration );
+        }
+    });
+
+    next(); // Pass control to the next middleware
+}

package/src/middleware/govcyReviewPageHandler.mjs

@@ -0,0 +1,102 @@
+import * as govcyResources from "../resources/govcyResources.mjs";
+import * as dataLayer from "../utils/govcyDataLayer.mjs";
+import { logger } from "../utils/govcyLogger.mjs";
+import {preparePrintFriendlyData , generateReviewSummary  } from "../utils/govcySubmitData.mjs";
+
+
+/**
+ * Middleware to handle the review page for the service.
+ * This middleware processes the review page, populates form data, and shows validation errors.
+ */
+export function govcyReviewPageHandler() {
+    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;
+            
+            // Deep copy renderer pageData from
+            let pageData = JSON.parse(JSON.stringify(govcyResources.staticResources.rendererPageData));
+            
+            // Base page template structure
+            let pageTemplate = {
+                sections: [
+                    {
+                        name: "beforeMain",
+                        elements: [govcyResources.staticResources.elements.backLink]
+                    }
+                ]
+            };
+            // Construct page title
+            const pageH1 = {
+                element: "textElement",
+                params: {
+                    type: "h1",
+                    text: govcyResources.staticResources.text.checkYourAnswersTitle
+                }
+            };
+            
+            // Construct submit button
+            const submitButton = {
+                element: "form",
+                params: {
+                    action: govcyResources.constructPageUrl(siteId, "review"),
+                    method: "POST",
+                    elements: [
+                        {
+                            element: "button",
+                            params: {
+                                type: "submit",
+                                variant: "success",
+                                text: govcyResources.staticResources.text.submit
+                            }
+                        }, govcyResources.csrfTokenInput(req.csrfToken())
+                    ]
+                }
+            }
+            // Generate the summary list using the utility function
+            let printFriendlyData = preparePrintFriendlyData(req, siteId, serviceCopy);
+            let summaryList = generateReviewSummary(printFriendlyData,req, siteId);
+            
+            //--------- Handle Validation Errors ---------
+            // Check if validation errors exist in the session
+            const validationErrors = dataLayer.getSiteSubmissionErrors(req.session, siteId);
+            let mainElements = [];
+            if (validationErrors ) {
+                for (const error in validationErrors.errors) {
+                    validationErrors.errorSummary.push({
+                        link: govcyResources.constructPageUrl(siteId, validationErrors.errors[error].pageUrl, "review"), //`/${siteId}/${error.pageUrl}`,
+                        text: validationErrors.errors[error].message
+                    });
+                }
+                mainElements.push(govcyResources.errorSummary(validationErrors.errorSummary));
+            } 
+            //--------- End Handle Validation Errors ---------
+
+            // Add elements to the main section, the H1, summary list, the submit button and the JS
+            mainElements.push(pageH1, summaryList, submitButton, 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.checkYourAnswersTitle;
+            
+            // Attach processed page data to the request
+            req.processedPage = {
+                pageData: pageData,
+                pageTemplate: pageTemplate
+            };
+            logger.debug("Processed review page data:", req.processedPage, req);
+            next();
+        } catch (error) {
+            return next(error); // Pass error to govcyHttpErrorHandler
+        }
+    };
+}

package/src/middleware/govcyReviewPostHandler.mjs

@@ -0,0 +1,147 @@
+import * as govcyResources from "../resources/govcyResources.mjs";
+import { validateFormElements  } from "../utils/govcyValidator.mjs"; // Import your validator
+import * as dataLayer from "../utils/govcyDataLayer.mjs";
+import { logger } from "../utils/govcyLogger.mjs";
+import {prepareSubmissionData, prepareSubmissionDataAPI, generateSubmitEmail } from "../utils/govcySubmitData.mjs";
+import { govcyApiRequest } from "../utils/govcyApiRequest.mjs";
+import { getEnvVariable } from "../utils/govcyEnvVariables.mjs";
+import { handleMiddlewareError } from "../utils/govcyUtils.mjs";
+import { sendEmail } from "../utils/govcyNotification.mjs"
+
+/**
+ * Middleware to handle review page form submission
+ * This middleware processes the review page, validates form data, and shows validation errors.
+ */
+export function govcyReviewPostHandler() {
+    return async (req, res, next) => {
+        try {
+            const { siteId } = req.params;
+    
+            // ✅ Load service and check if it exists
+            const service = req.serviceData;
+            let validationErrors = {};
+
+            // Loop through all pages in the service
+            for (const page of service.pages) {
+                //get page url
+                const pageUrl = page.pageData.url;
+                
+                // Find the form definition inside `pageTemplate.sections`
+                let formElement = null;
+                for (const section of page.pageTemplate.sections) {
+                    formElement = section.elements.find(el => el.element === "form");
+                    if (formElement) break;
+                }
+
+                if (!formElement) continue; // Skip pages without forms
+
+                // Get stored form data for this page (or default to empty)
+                const formData = dataLayer.getPageData(req.session, siteId, pageUrl) || {};
+                
+                // Run validations
+                const errors = validateFormElements(formElement.params.elements, formData, pageUrl);
+
+                // Add errors to the validationErrors object
+                validationErrors = { ...validationErrors, ...errors };
+            }
+
+            // ❌ Return validation errors if any exist
+            if (Object.keys(validationErrors).length > 0) {
+                logger.debug("🚨 Validation errors:", validationErrors, req);
+                logger.info("🚨 Validation errors:", req.originalUrl);
+                dataLayer.storeSiteValidationErrors(req.session, siteId, validationErrors);
+                //redirect to the same page with error summary
+                return res.redirect(govcyResources.constructErrorSummaryUrl(req.originalUrl));
+            } else {
+                // ------------ DO SUBMISSION ---------------------
+                // get the submission API endpoint URL, clientKey, serviceId from the environment variable (handle edge cases)
+                const submissionUrl = getEnvVariable(service?.site?.submissionAPIEndpoint?.url || "", false);
+                const clientKey = getEnvVariable(service?.site?.submissionAPIEndpoint?.clientKey || "", false);
+                const serviceId = getEnvVariable(service?.site?.submissionAPIEndpoint?.serviceId || "", false);
+                if (!submissionUrl) {
+                    return handleMiddlewareError("🚨 Submission API endpoint URL is missing", 500, next);
+                }
+                if (!clientKey) {
+                    return handleMiddlewareError("🚨 Submission API clientKey is missing", 500, next);
+                }
+                if (!serviceId) {
+                    return handleMiddlewareError("🚨 Submission API serviceId is missing", 500, next);
+                }
+                
+                // Prepare submission data
+                const submissionData = prepareSubmissionData(req, siteId, service);
+
+                // Prepare submission data for API
+                const submissionDataAPI = prepareSubmissionDataAPI(submissionData);
+                
+                // Call the API to submit the data
+                const response = await govcyApiRequest(
+                    "post",                         // Use POST method
+                    submissionUrl,                  // Use the submission URL from the environment variable
+                    submissionDataAPI,                 // Pass the prepared submission data
+                    true,                           // Use access token authentication
+                    dataLayer.getUser(req.session), // Get the user from the session
+                    { 
+                        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
+                    }        
+                );
+                
+                // Check if the response is successful
+                if (response.Succeeded) {
+                    let referenceNo = response?.Data?.submission_id || "";
+                    // Add the reference number to the submission data
+                    submissionData.referenceNumber = referenceNo; 
+                    logger.info("✅ Data submitted", siteId, referenceNo);
+                    // handle data layer submission
+                    dataLayer.storeSiteSubmissionData(
+                        req.session,
+                        siteId, 
+                        submissionData);
+                        
+                    //-- Send email to user
+                    // Generate the email body
+                    let emailBody = generateSubmitEmail(service, submissionData.print_friendly_data, referenceNo, req);
+                    logger.debug("Email generated:", emailBody);
+                    // Send the email
+                    sendEmail(service.site.title[service.site.lang],emailBody,[dataLayer.getUser(req.session).email], "eMail").catch(err => {
+                        logger.error("Email sending failed (async):", err);
+                    });
+                    // --- End of email sending
+                    
+                    logger.debug("🔄 Redirecting to success page:",  req);
+                    // redirect to success
+                    return res.redirect(govcyResources.constructPageUrl(siteId, `success`));
+                    
+                    // logger.debug("The submission data prepared:", printFriendlyData);
+                    // let reviewSummary = generateReviewSummary(printFriendlyData,req, siteId, false);
+                    // res.send(emailBody);
+                    
+                    // // Clear any existing submission errors from the session
+                    // dataLayer.clearSiteSubmissionErrors(req.session, siteId);
+                } else {
+                    // Handle submission failure
+                    const errorCode = response.ErrorCode;
+                    const errorPage = service.site?.submissionAPIEndpoint?.response?.errorResponse?.[errorCode]?.page;
+                    
+                    if (errorPage) {
+                        logger.info("🚨 Submission returned failed:", response.ErrorCode);
+                        return res.redirect(errorPage);
+                    } else {
+                        return handleMiddlewareError("🚨 Unknown error code received from API.", 500, next);
+                    }
+                }
+                
+            }
+
+            // Proceed to final submission if no errors
+            // return next();
+            // print the submission data to the page
+
+        } catch (error) {
+            return next(error);
+        }
+    };
+    
+}

package/src/middleware/govcyRoutePageHandler.mjs

@@ -0,0 +1,37 @@
+import { govcyFrontendRenderer } from '@gov-cy/govcy-frontend-renderer';
+import * as govcyResources from "../resources/govcyResources.mjs";
+import * as dataLayer from "../utils/govcyDataLayer.mjs";
+import {listAvailableSiteConfigs, getServiceConfigData} from "../utils/govcyLoadConfigData.mjs";
+
+/**
+ * Middleware function to handle the route page.
+ * This function renders the available services page with a list of available sites.
+ */
+export function govcyRoutePageHandler(req, res, next) {
+
+    // if current service cookie is set redirect to that page
+    if (req.cookies.cs) {
+        const siteId  = req.cookies.cs;
+        const serviceData = getServiceConfigData(siteId, req.globalLang);
+        if (serviceData.site && serviceData.site.homeRedirectPage) {
+            // redirect to the homeRedirectPage cookie
+            return res.redirect(serviceData.site.homeRedirectPage);
+        }
+    }
+
+   // Deep copy renderer pageData from
+    let pageData = JSON.parse(JSON.stringify(govcyResources.staticResources.rendererPageData));
+    const listOfAvailableSites = listAvailableSiteConfigs();
+
+    // Construct the page template
+    let pageTemplate = govcyResources.availableServicesPageTemplate(listOfAvailableSites, req.globalLang);
+    //use lang from middleware
+    pageData.site.lang = req.globalLang; 
+    //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
+    }
+    const renderer = new govcyFrontendRenderer();
+    const html = renderer.renderFromJSON(pageTemplate, pageData);
+    res.send(html);
+}