@piserve-tech/form-submission 1.3.317 → 1.3.319

package/esm2022/form-submission/submit-form/submit-form.component.mjs

@@ -0,0 +1,1610 @@
+import { Component, EventEmitter, Input, Output, ViewChild, } from '@angular/core';
+import * as mapper from '../../services/mapper.service';
+import { NavigationTabsComponent } from '../navigation-tabs/navigation-tabs.component';
+import { SaveDraftModalComponent } from '../save-as-draft/saveDraftModalComponent ';
+import { HttpEventType } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/form.service";
+import * as i2 from "ngx-toastr";
+import * as i3 from "@angular/router";
+import * as i4 from "../../services/data.service";
+import * as i5 from "../../services/recaptcha.service";
+import * as i6 from "../../services/validation.service";
+import * as i7 from "../../services/element-tracker.service";
+import * as i8 from "../../services/form-validation.service";
+import * as i9 from "../../services/aggregate.service";
+import * as i10 from "../../services/score.service";
+import * as i11 from "@angular/material/dialog";
+import * as i12 from "../../services/whenClause.service";
+import * as i13 from "@angular/common";
+import * as i14 from "ngx-skeleton-loader";
+import * as i15 from "../header/header.component";
+import * as i16 from "../navigation-tabs/navigation-tabs.component";
+import * as i17 from "../next-prev-navigation/next-prev-navigation.component";
+import * as i18 from "../submission-container/submission-container.component";
+export class SubmitFormComponent {
+    constructor(formService, toastr, router, dataService, recaptchaService, validationService, changeDetectorRef, elementTracker, formValidationService, aggregateService, scoreCalcService, dialog, whenClauseService) {
+        this.formService = formService;
+        this.toastr = toastr;
+        this.router = router;
+        this.dataService = dataService;
+        this.recaptchaService = recaptchaService;
+        this.validationService = validationService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.elementTracker = elementTracker;
+        this.formValidationService = formValidationService;
+        this.aggregateService = aggregateService;
+        this.scoreCalcService = scoreCalcService;
+        this.dialog = dialog;
+        this.whenClauseService = whenClauseService;
+        this.question = null;
+        this.moduleName = '';
+        this.edit = false;
+        this.submissionId = '';
+        this.acceptedLanguage = '';
+        this.skipMargin = false;
+        this.skipValidation = false;
+        this.navigateTo = '';
+        this.country = '';
+        this.submit = new EventEmitter();
+        this.apiCalled = new EventEmitter();
+        this.currentPageIndexChange = new EventEmitter();
+        this.showCancelButton = false;
+        this.cancel = new EventEmitter();
+        this.isActionTriggered = false;
+        this.isLoading = false;
+        this.name = '';
+        this.saveAutomatically = false;
+        this.saveInterval = 0;
+        this.customizeFont = false;
+        this.fontFamily = '';
+        this.fontSize = 0;
+        this.validationSkip = false;
+        this.enableDataExport = false;
+        this.fileFormats = [];
+        this.enableQuestionNumbering = false;
+        this.questionNumbering = '';
+        this.enableGoogleRecaptcha = false;
+        this.googleRecaptchaKey = '';
+        this.googleRecaptchaSecret = '';
+        this.navigation = '';
+        this.markAllQuestionsAsRequired = false;
+        this.pages = [];
+        this.currentPageIndex = 0;
+        this.previousPage = {};
+        this.currentPage = {};
+        this.nextPage = {};
+        this.lastTab = false;
+        this.questionAnswers = {
+            parentId: '',
+            answers: [],
+            forms: [],
+            copySubForms: [],
+            whenClauseElements: []
+        };
+        this.files = [];
+        this.submission = {};
+        this.parentSubmissionId = '';
+        this.submissionInProgress = false;
+        this.submissionInDraft = false;
+        this.recaptchaToken = '';
+        this.isRefreshing = false;
+        this.intervalId = null;
+        this.pageDetails = [];
+        this.pageNumber = 1;
+        this.rowSet = 0;
+        this.rowSetCount = [0];
+        this.retryCount = 0;
+        this.maxRetries = 5;
+        this.eligibleForSubmission = {
+            status: true,
+            message: '',
+        };
+        this.webhookPayloadArray = [];
+        this.inValidQuestions = new Map();
+        this.visitedRows = new Map();
+        this.allElementIds = [];
+        this.primaryColor = '#084fff';
+        this.secondaryColor = '';
+        this.isLoadingPages = false;
+        this.copySubforms = [];
+        this.emitters = [];
+        this.draft = false;
+        this.submissionProgress = 0;
+        this.showSubmissionLoader = false;
+        this.currentStep = 'Submitting form';
+        this.animatedDots = '';
+        this.updateSubForm = (pages, updatedSubForm) => {
+            pages.forEach((page) => {
+                page.rows.forEach((row) => {
+                    row.grid.forEach((element) => {
+                        if (element.entityType === 'SUBFORM' &&
+                            element.element.id === updatedSubForm.id) {
+                            // Update the existing subform with the new data
+                            element.element = updatedSubForm;
+                        }
+                        else if (element.entityType === 'SUBFORM' &&
+                            element.element.id !== updatedSubForm.formId) {
+                            // Handle multiple subforms logic here if needed
+                        }
+                        else if (element.entityType === 'QUESTION' &&
+                            element.element.childLogics) {
+                            // Recursively update child logics
+                            // element.element.childLogics.forEach((logic: any) => {
+                            //   if (logic.showLogic) {
+                            //     this.updateSubForm(logic.rows, updatedSubForm);
+                            //   }
+                            // });
+                        }
+                    });
+                });
+            });
+        };
+        const navigation = this.router.getCurrentNavigation();
+        this.submission = navigation?.extras.state?.['submission'];
+        this.parentSubmissionId = this.submission?.id;
+        this.parentQuestionAnswers = this.submission?.questionAnswers;
+        this.parentQuestions = navigation?.extras.state?.['parentQuestions'];
+        this.dataService.setParentQuestions(this.parentQuestions);
+    }
+    ngOnDestroy() {
+        this.visitedRows.clear();
+        this.recaptchaService.removeRecaptchaScript();
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+            this.isRefreshing = false;
+        }
+        this.aggregateService.clearAll();
+        this.recaptchaService.removeRecaptchaScript();
+        this.whenClauseService.resetService();
+    }
+    ngOnChanges(changes) {
+        if (changes['acceptedLanguage']) {
+            this.currentPageIndex = 0;
+            this.acceptedLanguage = changes['acceptedLanguage'].currentValue;
+            if (!this.edit)
+                this.getFormData();
+        }
+        if (changes['submissionId']) {
+            this.submissionId = changes['submissionId'].currentValue;
+            if (this.edit && this.submissionId) {
+                this.getSubmittedFormData();
+            }
+        }
+    }
+    ngOnInit() {
+        if (this.edit && this.submissionId) {
+            // this.getSubmittedFormData();
+        }
+        else {
+            // this.getFormData();
+        }
+        if (this.enableGoogleRecaptcha) {
+            this.recaptchaInitialized();
+        }
+    }
+    async recaptchaInitialized() {
+        await this.recaptchaService.initialize();
+        this.recaptchaService.render('captcha-container', (token) => { });
+    }
+    async getToken() {
+        return new Promise(async (resolve) => {
+            try {
+                await this.recaptchaService.initialize();
+                // Check if CAPTCHA was rendered
+                if (!this.recaptchaService.isRendered()) {
+                    console.warn('reCAPTCHA not rendered yet.');
+                    return resolve('');
+                }
+                // If solved, return the token
+                if (this.recaptchaService.isResolved()) {
+                    const token = this.recaptchaService.getResponse();
+                    return resolve(token);
+                }
+                // If expired or unsolved, return empty string
+                console.warn('reCAPTCHA not resolved or expired.');
+                return resolve('');
+            }
+            catch (err) {
+                console.error('reCAPTCHA initialization failed:', err);
+                return resolve('');
+            }
+        });
+    }
+    loadFont(fontName) {
+        const fontPath = `assets/fonts/${fontName}.woff2`; // Adjust extension as per your font file
+        const style = document.createElement('style');
+        style.innerHTML = `
+      @font-face {
+        font-family: '${fontName}';
+        src: url('${fontPath}') format('woff2');
+        font-weight: normal;
+        font-style: normal;
+      }
+      body {
+        font-family: '${fontName}', sans-serif;
+      }
+    `;
+        document.head.appendChild(style);
+    }
+    getFormData() {
+        this.isLoadingPages = true;
+        this.formService
+            .getQuestions(this.moduleName, 1, 0, true, this.country)
+            .subscribe((response) => {
+            this.isLoadingPages = false;
+            this.enableGoogleRecaptcha =
+                response.result.moduleConfiguration?.enableGoogleRecaptcha;
+            this.question = mapper.mapPublicFormToModel(response);
+            this.emitters = this.question.emitters || [];
+            this.assignQuestionProperties(this.question);
+            this.setUpFontFamily(response);
+            this.primaryColor = response.result.primaryColor || '#084fff';
+            this.secondaryColor = response.result.secondaryColor;
+            if (this.enableGoogleRecaptcha)
+                this.recaptchaInitialized();
+            if (response?.result?.pageDetails) {
+                this.pageDetails = response.result.pageDetails;
+                this.nextPage = this.pageDetails[1];
+            }
+            this.webhook = response?.result?.webhooks;
+            this.webhookPayloadArray = response?.result?.webhooks?.map((w) => ({
+                id: w.id,
+                ...this.extractGroupedWebhookData([w]),
+            }));
+            this.rowSetCount[0] = response.result.totalNumberRow;
+            for (let i = 0; i < this.pageDetails.length; i++) {
+                if (!this.pages[i]) {
+                    this.pages[i] = [];
+                }
+            }
+            this.checkSubmissionEligibility();
+        });
+    }
+    getSubmittedFormData() {
+        this.formService
+            .getSubmittedForm(this.moduleName, this.submissionId, 1, 0, this.navigateTo)
+            .subscribe((response) => {
+            this.enableGoogleRecaptcha =
+                response.result.moduleConfiguration.enableGoogleRecaptcha;
+            this.question = mapper.mapPublicFormToModel(response);
+            this.assignQuestionProperties(this.question);
+            this.primaryColor = response.result.primaryColor || '#084fff';
+            this.secondaryColor = response.result.secondaryColor;
+            this.emitters = this.question.emitters || [];
+            if (response?.result?.pageDetails) {
+                this.pageDetails = response.result.pageDetails;
+                this.nextPage = this.pageDetails[1];
+            }
+            this.webhookPayloadArray;
+            this.webhookPayloadArray = response?.result?.webhooks?.map((w) => ({
+                id: w.id,
+                ...this.extractGroupedWebhookData([w]),
+            }));
+            this.rowSetCount[0] = response.result.totalNumberRow;
+            for (let i = 0; i < this.pageDetails.length; i++) {
+                if (!this.pages[i]) {
+                    this.pages[i] = [];
+                }
+            }
+            this.setUpFontFamily(response);
+            if (this.navigateTo) {
+                setTimeout(() => {
+                    this.navigateToFormElement();
+                });
+            }
+            if (this.enableGoogleRecaptcha) {
+                this.recaptchaInitialized();
+            }
+            this.checkSubmissionEligibility();
+        });
+    }
+    setUpFontFamily(response) {
+        //set font family and font size
+        if (response.result?.moduleConfiguration?.customizeFont) {
+            this.fontFamily = response.result.moduleConfiguration?.fontFamily;
+            this.fontSize = response.result.moduleConfiguration?.fontSize || 18;
+        }
+        else {
+            this.fontFamily = 'Poppins';
+            this.fontSize = 18;
+        }
+        this.loadFont(this.fontFamily);
+        document.documentElement.style.setProperty('--library-font-family', this.fontFamily);
+        document.documentElement.style.setProperty('--library-font-size', this.fontSize + 'px');
+    }
+    navigateToFormElement() {
+        if (!this.pages)
+            return;
+        let foundPageIndex = null;
+        // Step 1: find the page index
+        this.pages.forEach((page, pageIndex) => {
+            if (!page?.rows)
+                return;
+            page.rows.forEach((row) => {
+                if (!row?.grid)
+                    return;
+                row.grid.forEach((gridItem) => {
+                    const element = gridItem?.element;
+                    if (!element)
+                        return;
+                    // Case 1: Direct question match
+                    if (gridItem.entityType === 'QUESTION' &&
+                        element.id === this.navigateTo) {
+                        foundPageIndex = pageIndex;
+                    }
+                    // Case 2: Subform match
+                    if (gridItem.entityType === 'SUBFORM') {
+                        if (element.id === this.navigateTo) {
+                            foundPageIndex = pageIndex;
+                        }
+                        if (element.submissions?.some((s) => s.submissionId === this.navigateTo)) {
+                            foundPageIndex = pageIndex;
+                        }
+                    }
+                });
+            });
+        });
+        if (foundPageIndex !== null) {
+            // Step 2: Set current page
+            this.currentPageIndex = foundPageIndex;
+            this.currentPage = this.pages[this.currentPageIndex];
+            if (this.navigation == 'TAB') {
+                this.child.triggerFunction(this.currentPageIndex);
+            }
+            else {
+                this.previousPage = this.pageDetails[this.currentPageIndex - 1];
+                this.nextPage = this.pageDetails[this.currentPageIndex + 1];
+            }
+            // Step 3: Wait for DOM render and scroll
+            setTimeout(() => {
+                const elementId = `question-${this.navigateTo}`;
+                const el = document.getElementById(elementId);
+                if (el) {
+                    el.scrollIntoView({ behavior: 'smooth', block: 'center' });
+                    this.checkSubmissionEligibility();
+                }
+            }, 0);
+        }
+        else {
+            console.warn(`navigateTo id ${this.navigateTo} not found in any page`);
+        }
+    }
+    assignQuestionProperties(question) {
+        this.name = question.name;
+        this.pages = question.pages;
+        if (this.parentQuestions) {
+            this.parentQuestionAnswers = question?.questionAnswers;
+            this.parentSubmissionId = question?.parentId;
+        }
+        this.currentPage = this.pages[0];
+        this.nextPage = this.pages[1];
+        this.saveAutomatically = question.formConfiguration.saveAutomatically;
+        this.saveInterval = question.formConfiguration.saveInterval;
+        this.customizeFont = question.formConfiguration.customizeFont;
+        this.fontFamily = question.formConfiguration.fontFamily;
+        this.fontSize = question.formConfiguration.fontSize;
+        this.enableDataExport = question.formConfiguration.enableDataExport;
+        this.fileFormats = question.formConfiguration.fileFormats;
+        this.enableQuestionNumbering =
+            question.formConfiguration.enableQuestionNumbering;
+        this.questionNumbering = question.formConfiguration.questionNumbering;
+        this.enableGoogleRecaptcha =
+            question.formConfiguration.enableGoogleRecaptcha;
+        this.googleRecaptchaKey = question.formConfiguration.googleRecaptchaKey;
+        this.googleRecaptchaSecret =
+            question.formConfiguration.googleRecaptchaSecret;
+        this.navigation = question.formConfiguration.navigation;
+        this.markAllQuestionsAsRequired =
+            question.formConfiguration.markAllQuestionsAsRequired;
+        this.apiCalled.emit(true);
+    }
+    navigateToNextPage() {
+        if (!this.isLoading) {
+            this.isLoading = true;
+            const nextIndex = this.currentPageIndex + 1;
+            if (nextIndex < this.pageDetails.length) {
+                if (this.markAllQuestionsAsRequired) {
+                    const currentPageData = this.pages[this.currentPageIndex];
+                    let validationResponse = true;
+                    if (!this.validationSkip) {
+                        validationResponse =
+                            this.formValidationService.validateRequiredQuestions(currentPageData).isValid;
+                    }
+                    if (validationResponse) {
+                        this.previousPage = this.pageDetails[this.currentPageIndex];
+                        if (this.pages[nextIndex].length != 0) {
+                            this.currentPage = this.pages[nextIndex];
+                            this.currentPageIndex = nextIndex;
+                        }
+                        else {
+                            this.setCurrentPage(nextIndex);
+                        }
+                        this.nextPage = this.pageDetails[nextIndex + 1];
+                    }
+                }
+                else {
+                    this.previousPage = this.pageDetails[this.currentPageIndex];
+                    if (this.pages[nextIndex].length != 0) {
+                        this.currentPage = this.pages[nextIndex];
+                        this.currentPageIndex = nextIndex;
+                    }
+                    else {
+                        this.setCurrentPage(nextIndex);
+                    }
+                    this.nextPage = this.pageDetails[nextIndex + 1];
+                }
+            }
+            this.isLoading = false;
+            this.checkSubmissionEligibility();
+        }
+    }
+    navigateToPreviousPage() {
+        if (this.currentPageIndex > 0) {
+            if (this.markAllQuestionsAsRequired) {
+                const currentPageData = this.pages[this.currentPageIndex];
+                let validationResponse = true;
+                if (!this.validationSkip) {
+                    validationResponse =
+                        this.formValidationService.validateRequiredQuestions(currentPageData).isValid;
+                }
+                if (validationResponse) {
+                    this.nextPage = this.pageDetails[this.currentPageIndex];
+                    this.currentPageIndex--;
+                    if (this.pages[this.currentPageIndex].length != 0) {
+                        this.currentPage = this.pages[this.currentPageIndex];
+                    }
+                    else {
+                        this.setCurrentPage(this.currentPageIndex);
+                    }
+                    this.previousPage = this.pageDetails[this.currentPageIndex - 1];
+                }
+            }
+            else {
+                this.nextPage = this.pageDetails[this.currentPageIndex];
+                this.currentPageIndex--;
+                if (this.pages[this.currentPageIndex].length != 0) {
+                    this.currentPage = this.pages[this.currentPageIndex];
+                }
+                else {
+                    this.setCurrentPage(this.currentPageIndex);
+                }
+                this.previousPage = this.pageDetails[this.currentPageIndex - 1];
+            }
+        }
+        this.checkSubmissionEligibility();
+    }
+    checkSubmissionEligibility() {
+        this.eligibleForSubmission = this.validateAllElementLoaded();
+    }
+    setCurrentPage(index) {
+        if (index < this.pages.length) {
+            // If page already exists AND has content → no need to fetch again
+            if (this.pages[index] &&
+                this.pages[index].rows &&
+                this.pages[index].rows.length > 0) {
+                this.checkSubmissionEligibility();
+                return;
+            }
+        }
+        this.pageNumber = index + 1;
+        if (this.edit) {
+            this.formService
+                .getSubmittedForm(this.moduleName, this.submissionId, this.pageNumber, this.rowSet)
+                .subscribe((response) => {
+                const mappedResponse = mapper.mapPageToModel(response.result.pages[0], response.result?.currency, response.result?.defaultCurrency);
+                if (mappedResponse) {
+                    this.pages[index] = mappedResponse;
+                }
+                this.currentPageIndex = index;
+                this.currentPage = this.pages[index];
+                this.rowSetCount[index] = response.result.totalNumberRow;
+                this.checkSubmissionEligibility();
+            });
+        }
+        else {
+            this.formService
+                .getQuestions(this.moduleName, this.pageNumber, this.rowSet, true, this.country)
+                .subscribe((response) => {
+                const mappedResponse = mapper.mapPageToModel(response.result.pages[0], response.result?.currency, response.result?.defaultCurrency);
+                if (mappedResponse) {
+                    this.pages[index] = mappedResponse;
+                }
+                this.currentPageIndex = index;
+                this.currentPage = this.pages[index];
+                this.rowSetCount[index] = response.result.totalNumberRow;
+                this.checkSubmissionEligibility();
+            });
+        }
+        if (this.markAllQuestionsAsRequired) {
+            const currentPageData = this.pages[this.currentPageIndex];
+            let validationResponse = true;
+            if (!this.validationSkip) {
+                validationResponse =
+                    this.formValidationService.validateRequiredQuestions(currentPageData).isValid;
+            }
+            if (validationResponse) {
+                this.currentPageIndex = index;
+            }
+            else {
+                this.checkSubmissionEligibility();
+                return;
+            }
+        }
+        else {
+            this.checkSubmissionEligibility();
+            this.currentPageIndex = index;
+        }
+    }
+    loadMoreData(index) {
+        if (!this.isLoading) {
+            this.isLoading = true;
+            let rowCountLimit = this.rowSetCount[index];
+            let i = 0;
+            this.pages[index].rows.forEach((row) => {
+                row.grid.forEach((gridItem) => {
+                    i++;
+                });
+            });
+            let rowCount = i / 20;
+            rowCount = Math.ceil(rowCount);
+            if (this.visitedRows.has(index)) {
+                if (this.visitedRows.get(index) === rowCount) {
+                    this.isLoading = false;
+                    return;
+                }
+            }
+            if (rowCount + 1 > rowCountLimit && !this.navigateTo) {
+                this.checkSubmissionEligibility();
+                this.isLoading = false;
+                return;
+            }
+            this.visitedRows.set(index, rowCount);
+            if (this.edit) {
+                this.formService
+                    .getSubmittedForm(this.moduleName, this.submissionId, index + 1, rowCount)
+                    .subscribe((response) => {
+                    const newRows = response?.result?.pages[0]?.rows ?? [];
+                    this.pages[index].rows = [
+                        ...(this.pages[index]?.rows ?? []),
+                        ...newRows,
+                    ];
+                    this.currentPageIndex = index;
+                    this.currentPage = this.pages[index];
+                    this.rowSetCount[index] = response.result.totalNumberRow;
+                    this.checkSubmissionEligibility();
+                    this.isLoading = false;
+                });
+            }
+            else {
+                this.formService
+                    .getQuestions(this.moduleName, index + 1, rowCount)
+                    .subscribe((response) => {
+                    const newRows = response?.result?.pages[0]?.rows ?? [];
+                    this.pages[index].rows = [
+                        ...(this.pages[index]?.rows ?? []),
+                        ...newRows,
+                    ];
+                    this.currentPageIndex = index;
+                    this.currentPage = this.pages[index];
+                    this.rowSetCount[index] = response.result.totalNumberRow;
+                    this.checkSubmissionEligibility();
+                    this.isLoading = false;
+                });
+            }
+            this.checkSubmissionEligibility();
+        }
+    }
+    generateQuestionAnswers() {
+        this.maxPossibleScore = 1;
+        this.sumOfFindings = 0;
+        this.sumOfBadFindings = 0;
+        this.sumOfGoodFindings = 0;
+        this.maxPossibleBadScore = 0;
+        this.maxPossibleGoodScore = 0;
+        this.copySubforms = [];
+        // this.maxPossibleGoodScore = 0;
+        // this.maxPossibleBadScore = 0;
+        const extractQuestions = (formElements, parentFormId = null, isInSubForm = false, subFormIndex = 0) => {
+            const questions = [];
+            const forms = [];
+            formElements.forEach((element) => {
+                if (element.entityType === 'QUESTION' && element.show) {
+                    let baseQuestion;
+                    if (element.element.formElement.elementType === 'FILE_PICKER') {
+                        baseQuestion = {
+                            questionId: element.element.id,
+                            answer: '',
+                        };
+                        if (Array.isArray(element.element.answer)) {
+                            const questionId = isInSubForm
+                                ? `${parentFormId}_${subFormIndex}_${element.element.id}`
+                                : element.element.id;
+                            this.files.push({
+                                questionId: questionId,
+                                file: element.element.answer,
+                                show: element.show
+                            });
+                        }
+                    }
+                    else {
+                        baseQuestion = {
+                            questionId: element.element.id,
+                            answer: element.element.answer,
+                            score: element.element.score,
+                            maximumPossibleScore: element.element.maxPossibleScore,
+                            currencySymbol: element.element?.currencySymbol,
+                            amountInWords: element.element?.amountInWords,
+                            show: element.show
+                        };
+                    }
+                    if (this.edit) {
+                        questions.push({
+                            ...baseQuestion,
+                            answerId: element.element.answerId || '',
+                            deleteFiles: element.element.deleteFiles || [],
+                        });
+                    }
+                    else {
+                        questions.push(baseQuestion);
+                    }
+                    if ((element.element.formElement.elementType === 'DROP_DOWN' ||
+                        element.element.formElement.elementType === 'RADIO_BUTTON' ||
+                        element.element.formElement.elementType === 'CHECK_BOX') &&
+                        element.element.formElement.scoring &&
+                        element.element.formElement.scoring.enableScoring &&
+                        !isInSubForm) {
+                        this.maxPossibleScore *=
+                            this.scoreCalcService.getMaxPossibleScoreForQuestion(element.element);
+                        if (element.element.score &&
+                            element.element.score != null &&
+                            element.element.score != undefined) {
+                            this.sumOfFindings += element.element.score;
+                        }
+                    }
+                    if (element.element.childLogics) {
+                        for (let logic of element.element.childLogics) {
+                            if (logic.showLogic) {
+                                for (let row of logic.rows) {
+                                    const result = extractQuestions(row.grid, parentFormId, isInSubForm, subFormIndex);
+                                    questions.push(...result.answers);
+                                    forms.push(...result.forms);
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (element.entityType === 'SUBFORM' && element.show) {
+                    const subformId = element.element.id;
+                    const submissionId = element.element.submissionId;
+                    if (element.element.copySubformMeta) {
+                        this.copySubforms.push(element.element.copySubformMeta);
+                    }
+                    if (element.element.property.subFormStructure === 'single') {
+                        let allAnswers = [];
+                        element.element.rows.forEach((row) => {
+                            const extracted = extractQuestions(row.grid, subformId, true, forms.length);
+                            extracted.answers.forEach((answer) => {
+                                allAnswers.push({ ...answer });
+                            });
+                        });
+                        let copiedForms;
+                        if (element.element.copiedForms) {
+                            copiedForms = element.element.copiedForms;
+                        }
+                        const subform = {
+                            formId: subformId,
+                            deleted: element.element.deleted,
+                            deletedSubmissions: [],
+                            submissions: [
+                                {
+                                    submissionId: submissionId,
+                                    answers: allAnswers,
+                                },
+                            ],
+                            copiedForms: copiedForms,
+                        };
+                        forms.push(subform);
+                    }
+                    else if (element.element.property.subFormStructure === 'multiple') {
+                        const subformAnswers = [];
+                        let subformQuestions = { answers: [] };
+                        element.element.rows.forEach((row) => {
+                            subformQuestions = extractQuestions(row.grid, subformId, true, forms.length);
+                        });
+                        const existingSubform = forms.find((form) => form.formId === subformId);
+                        if ((element.element.property.subFormType == 'inline' ||
+                            element.element.property.subFormType == 'card') &&
+                            element.element.submissions) {
+                            element.element.submissions = this.clearEmptySubmissions(element.element.submissions);
+                        }
+                        element.element?.submissions?.forEach((submission, index) => {
+                            for (const s of submission.scores ?? []) {
+                                if (s.scoreType === 'GOOD_SCORE') {
+                                    this.sumOfGoodFindings += s.score;
+                                }
+                                if (s.scoreType === 'BAD_SCORE') {
+                                    this.sumOfBadFindings += s.score;
+                                }
+                            }
+                            delete submission.hasAllScoringAnsweredOnce;
+                            submission.answers.forEach((answer) => {
+                                delete answer.htmlContent;
+                                if (Array.isArray(answer.files)) {
+                                    const questionId = `${subformId}_${index}_${answer.questionId}`;
+                                    this.files.push({
+                                        questionId: questionId,
+                                        file: answer.files,
+                                    });
+                                    delete answer.files;
+                                }
+                                delete answer.attachments;
+                            });
+                        });
+                        let copiedForms;
+                        if (element.element.copiedForms) {
+                            copiedForms = element.element.copiedForms;
+                        }
+                        const subform = {
+                            formId: subformId,
+                            deleted: element.element.deleted,
+                            scores: element.element.scores,
+                            deletedSubmissions: element.element.deletedSubmissions,
+                            submissions: element.element.submissions,
+                            copiedForms: copiedForms,
+                        };
+                        forms.push(subform);
+                        this.maxPossibleScore +=
+                            element.element?.maxPossibleScore *
+                                element.element?.submissions?.length;
+                        this.maxPossibleGoodScore +=
+                            element.element?.maxPossibleScore?.good *
+                                element.element?.submissions?.length || 0;
+                        this.maxPossibleBadScore +=
+                            element.element?.maxPossibleScore?.bad *
+                                element.element?.submissions?.length || 0;
+                    }
+                }
+                else if (element.entityType === 'QUESTION_GROUP' && element.show) {
+                    // Handle Question Group by iterating through rows
+                    element.element.rows.forEach((row) => {
+                        row.grid.forEach((gridItem) => {
+                            if (gridItem.entityType === 'QUESTION' && gridItem.show) {
+                                let baseQuestion;
+                                if (gridItem.element?.formElement.elementType === 'FILE_PICKER') {
+                                    baseQuestion = {
+                                        questionId: gridItem.element.id,
+                                        answer: '',
+                                    };
+                                    if (Array.isArray(gridItem.element.answer)) {
+                                        const questionId = isInSubForm
+                                            ? `${parentFormId}_${subFormIndex}_${gridItem.element.id}`
+                                            : gridItem.element.id;
+                                        this.files.push({
+                                            questionId: questionId,
+                                            file: gridItem.element.answer,
+                                        });
+                                    }
+                                }
+                                else {
+                                    baseQuestion = {
+                                        questionId: gridItem.element.id,
+                                        answer: gridItem.element.answer,
+                                        amountInWords: gridItem.element.amountInWords
+                                    };
+                                }
+                                if (this.edit) {
+                                    questions.push({
+                                        ...baseQuestion,
+                                        answerId: gridItem.element.answerId || '',
+                                        deleteFiles: gridItem.element.deleteFiles || [],
+                                    });
+                                }
+                                else {
+                                    questions.push(baseQuestion);
+                                }
+                                if (gridItem.element.childLogics) {
+                                    for (let logic of gridItem.element.childLogics) {
+                                        if (logic.showLogic) {
+                                            for (let row of logic.rows) {
+                                                const result = extractQuestions(row.grid, parentFormId, isInSubForm, subFormIndex);
+                                                questions.push(...result.answers);
+                                                forms.push(...result.forms);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        });
+                    });
+                }
+                else if (element.entityType === 'MULTIFIELD' && element.show) {
+                    element.element.rows.forEach((row) => {
+                        row.grid.forEach((gridItem) => {
+                            if (gridItem.entityType === 'QUESTION' && gridItem.show) {
+                                questions.push({
+                                    questionId: gridItem.element.id,
+                                    answer: gridItem.element.answer || '',
+                                });
+                            }
+                        });
+                    });
+                }
+            });
+            return { answers: questions, forms: forms };
+        };
+        const processPages = (pages) => {
+            const questions = [];
+            const forms = [];
+            pages.forEach((page) => {
+                page.rows.forEach((row) => {
+                    const result = extractQuestions(row.grid);
+                    questions.push(...result.answers);
+                    forms.push(...result.forms);
+                });
+            });
+            return { answers: questions, forms: forms };
+        };
+        const result = processPages(this.pages);
+        const grids = this.whenClauseService.getActiveWhenClauseGrids();
+        const simplified = grids.map(grid => ({
+            elementId: grid?.element?.id ?? null,
+            entityType: grid?.entityType ?? null,
+            show: grid?.show ?? false
+        }));
+        this.questionAnswers = {
+            parentId: '',
+            answers: result.answers,
+            forms: result.forms,
+            copySubForms: this.copySubforms,
+            whenClauseElements: simplified
+        };
+    }
+    clearEmptySubmissions(submissions) {
+        const nonEmptySubmissions = [];
+        const emptySubmissionIds = [];
+        submissions.forEach((submission) => {
+            const hasValue = submission.answers.some((answer) => answer.answer !== '' &&
+                answer.answer !== null &&
+                answer.answer !== undefined);
+            if (hasValue) {
+                nonEmptySubmissions.push(submission);
+            }
+            else if (submission.submissionId) {
+                emptySubmissionIds.push(submission.submissionId);
+            }
+        });
+        submissions = nonEmptySubmissions;
+        return submissions;
+    }
+    validateAllElementLoaded() {
+        if (this.pages.length < this.pageDetails.length) {
+            return {
+                status: false,
+                message: 'Please ensure all pages are fully visible before submitting the form.',
+            };
+        }
+        const incompletePages = [];
+        this.pages.forEach((p, i) => {
+            if (p && Array.isArray(p.rows)) {
+                let j = 0;
+                p.rows.forEach((row) => {
+                    row.grid.forEach((gridItem) => {
+                        j++;
+                    });
+                });
+                if (!p ||
+                    !Array.isArray(p.rows) ||
+                    (Math.ceil(j / 20) != this.rowSetCount[i] && !this.navigateTo)) {
+                    incompletePages.push(this.pageDetails[i].name);
+                }
+            }
+            else {
+                incompletePages.push(this.pageDetails[i].name);
+            }
+        });
+        if (incompletePages.length > 0) {
+            return {
+                status: false,
+                message: `Some sections are still loading. Please scroll through the following pages to ensure all questions are loaded: ${incompletePages.join(', ')}.`,
+            };
+        }
+        return {
+            status: true,
+            message: 'Great! All sections are complete. You can now submit the form.',
+        };
+    }
+    saveasDraftPopup() {
+        if (!this.skipValidation) {
+            return;
+        }
+        const dialogRef = this.dialog.open(SaveDraftModalComponent, {
+            width: '450px',
+            panelClass: 'custom-dialog-container',
+            autoFocus: false,
+            disableClose: true,
+            data: {
+                primaryColor: this.primaryColor,
+            },
+        });
+        dialogRef.afterClosed().subscribe((result) => {
+            if (result) {
+                this.validationSkip = true;
+                this.submitForm();
+            }
+            else {
+                this.validationSkip = false;
+            }
+        });
+    }
+    saveAsDraft() {
+        this.validationSkip = true;
+        this.draft = true;
+        this.submitForm();
+    }
+    async submitForm() {
+        this.startSubmissionLoader();
+        if (this.webhook) {
+            this.webhookPayloadArray = this.webhook.map((w) => ({
+                id: w.id,
+                ...this.extractGroupedWebhookData([w]),
+            }));
+        }
+        if (!this.validateAllElementLoaded().status) {
+            this.toastr.warning('Please wait for all elements to load');
+            this.submit.emit({
+                status: 'failed',
+            });
+            return;
+        }
+        if (this.submissionInProgress || this.submissionInDraft) {
+            this.submit.emit({
+                status: 'failed',
+            });
+            return;
+        }
+        let recaptchaToken;
+        this.inValidQuestions.clear();
+        this.validationService.clearAll();
+        if (this.enableGoogleRecaptcha) {
+            try {
+                recaptchaToken = await this.getToken();
+                if (!recaptchaToken) {
+                    this.toastr.error('Please complete the CAPTCHA verification before submitting the form.');
+                    this.submissionInProgress = false;
+                    this.submissionInDraft = false;
+                    this.resetSubmissionLoader();
+                    this.validationSkip = false;
+                    this.draft = false;
+                    this.submit.emit({
+                        status: 'failed',
+                    });
+                    return;
+                }
+            }
+            catch (error) {
+                console.error('Error while getting reCAPTCHA token:', error.error?.message);
+                this.toastr.error('Failed to verify reCAPTCHA.');
+                this.submissionInProgress = false;
+                this.submissionInDraft = false;
+                this.resetSubmissionLoader();
+                this.validationSkip = false;
+                this.draft = false;
+                this.submit.emit({
+                    status: 'failed',
+                });
+                return;
+            }
+        }
+        if (this.draft || this.validationSkip) {
+            this.submissionInDraft = true;
+        }
+        else {
+            this.submissionInProgress = true;
+        }
+        let validationResponse = true;
+        if (!this.validationSkip) {
+            validationResponse = this.validateForm(this.pages).isValid;
+        }
+        if (!validationResponse) {
+            this.saveasDraftPopup();
+            this.submissionInProgress = false;
+            this.submissionInDraft = false;
+            this.resetSubmissionLoader();
+            this.validationSkip = false;
+            this.draft = false;
+            this.submit.emit({
+                status: 'failed',
+            });
+            return;
+        }
+        const getCircularReplacer = () => {
+            const seen = new WeakSet();
+            return (_key, value) => {
+                if (typeof value === 'object' && value !== null) {
+                    if (seen.has(value)) {
+                        return undefined;
+                    }
+                    seen.add(value);
+                }
+                return value;
+            };
+        };
+        this.generateQuestionAnswers();
+        const formFinalScore = this.calculateFormFinalScore();
+        this.questionAnswers.scores = formFinalScore;
+        if (validationResponse) {
+            const formData = new FormData();
+            formData.append('skipValidation', this.validationSkip ? 'true' : 'false');
+            this.questionAnswers.parentId = this.parentSubmissionId;
+            formData.append('json', JSON.stringify(this.questionAnswers, getCircularReplacer()));
+            if (this.webhookPayloadArray) {
+                formData.append('webhookPayload', JSON.stringify(this.webhookPayloadArray));
+            }
+            else {
+                formData.append('webhookPayload', JSON.stringify([]));
+            }
+            if (this.files.length > 0) {
+                const seenQuestionIds = new Set();
+                const uniqueFiles = this.files.filter((fileItem) => {
+                    if (seenQuestionIds.has(fileItem.questionId)) {
+                        return false;
+                    }
+                    seenQuestionIds.add(fileItem.questionId);
+                    return true;
+                });
+                uniqueFiles.forEach((fileItem) => {
+                    fileItem.file.forEach((file) => {
+                        formData.append(fileItem.questionId, file._file);
+                    });
+                });
+            }
+            const formServiceCall = this.edit && this.submissionId
+                ? this.formService.updateForm(this.moduleName, this.submissionId, formData, recaptchaToken ?? '')
+                : this.formService.submitForm(this.moduleName, formData, recaptchaToken ?? '');
+            formServiceCall.subscribe({
+                next: (event) => {
+                    if (event.type === HttpEventType.UploadProgress) {
+                        if (event.total) {
+                            const percentDone = Math.round((event.loaded / event.total) * 100);
+                            this.setProgress(Math.min(95, percentDone));
+                        }
+                    }
+                    if (event.type === HttpEventType.Response) {
+                        this.completeSubmissionLoader();
+                        const response = event.body;
+                        // existing success logic ↓
+                        this.toastr.success(this.edit
+                            ? 'Form updated successfully'
+                            : 'Form submitted successfully');
+                        let emittingValues;
+                        if (this.emitters) {
+                            emittingValues = this.mapEmittersToValues();
+                        }
+                        if (this.validationSkip || this.draft) {
+                            this.submit.emit({
+                                status: 'draft',
+                                submissionId: response.result,
+                                score: formFinalScore,
+                                ...(emittingValues || {}),
+                            });
+                        }
+                        else {
+                            this.submit.emit({
+                                status: 'success',
+                                submissionId: response.result,
+                                score: formFinalScore,
+                                ...(emittingValues || {}),
+                            });
+                        }
+                        this.submissionInProgress = false;
+                        this.submissionInDraft = false;
+                        this.draft = false;
+                        this.validationSkip = false;
+                    }
+                },
+                error: (error) => {
+                    this.validationService.clearAll();
+                    this.findQuestionPageIndex(this.parseErrorsToMap(error.error.message));
+                    this.currentPageIndex = this.pages.length - 1;
+                    this.navigateToFirstError();
+                    this.resetSubmissionLoader();
+                    this.submissionInProgress = false;
+                    this.draft = false;
+                    this.validationSkip = false;
+                    this.submissionInDraft = false;
+                    this.saveasDraftPopup();
+                    this.submit.emit({
+                        status: 'failed',
+                        message: error.error.message
+                    });
+                },
+            });
+        }
+        else {
+            // this.toastr.error(validationResponse.message);
+            this.submit.emit({
+                status: 'failed',
+            });
+            this.saveasDraftPopup();
+            this.submissionInProgress = false;
+            this.submissionInDraft = false;
+            this.resetSubmissionLoader();
+            this.validationSkip = false;
+            this.draft = false;
+        }
+    }
+    setProgress(value) {
+        this.submissionProgress = value;
+        this.updateStepText(value);
+    }
+    startSubmissionLoader() {
+        this.showSubmissionLoader = true;
+        this.setProgress(0);
+        // Simulated progress until backend upload updates it
+        this.progressInterval = setInterval(() => {
+            if (this.submissionProgress < 85) {
+                this.setProgress(this.submissionProgress + 2);
+            }
+        }, 300);
+    }
+    completeSubmissionLoader() {
+        clearInterval(this.progressInterval);
+        this.setProgress(100);
+        setTimeout(() => {
+            this.showSubmissionLoader = false;
+            this.setProgress(0);
+        }, 500);
+    }
+    resetSubmissionLoader() {
+        clearInterval(this.progressInterval);
+        this.showSubmissionLoader = false;
+        clearInterval(this.dotInterval);
+        this.animatedDots = '';
+        this.setProgress(0);
+    }
+    startTextLoader() {
+        let dotCount = 0;
+        this.dotInterval = setInterval(() => {
+            dotCount = (dotCount + 1) % 4;
+            this.animatedDots = '.'.repeat(dotCount);
+        }, 500);
+    }
+    updateStepText(progress) {
+        if (progress < 25) {
+            this.currentStep = 'Validating form';
+        }
+        else if (progress < 60) {
+            this.currentStep = 'Uploading data';
+        }
+        else if (progress < 90) {
+            this.currentStep = 'Saving submission';
+        }
+        else {
+            this.currentStep = 'Finalizing';
+        }
+    }
+    calculateFormFinalScore() {
+        const goodScore = this.maxPossibleGoodScore
+            ? 100 - (this.sumOfGoodFindings / this.maxPossibleGoodScore) * 100
+            : 0;
+        const badScore = this.maxPossibleBadScore
+            ? 100 - (this.sumOfBadFindings / this.maxPossibleBadScore) * 100
+            : 0;
+        return [
+            { scoreType: 'GOOD_SCORE', score: Math.round(goodScore) },
+            { scoreType: 'BAD_SCORE', score: Math.round(badScore) },
+        ];
+    }
+    mapEmittersToValues() {
+        const answerMap = new Map(this.questionAnswers.answers.map((qa) => [qa.questionId, qa.answer]));
+        const result = {};
+        this.emitters.forEach((emitter) => {
+            if (emitter.valueSource === 'CUSTOM_INPUT') {
+                result[emitter.keyName] = emitter.inputValue;
+            }
+            else if (emitter.valueSource === 'QUESTION' &&
+                emitter.questionId &&
+                answerMap.has(emitter.questionId)) {
+                result[emitter.keyName] = answerMap.get(emitter.questionId);
+            }
+        });
+        return result;
+    }
+    parseErrorsToMap(errorString) {
+        const errorMap = new Map();
+        // Convert the incorrect format to a valid object structure
+        errorString
+            .replace(/[{}]/g, '') // Remove curly braces
+            .split(', ') // Split key-value pairs
+            .forEach((pair) => {
+            const [key, value] = pair.split('=');
+            if (key && value) {
+                errorMap.set(key.trim(), value.trim()); // Store in Map
+            }
+        });
+        return errorMap;
+    }
+    async navigateToFirstError() {
+        const firstError = this.validationService.getFirstInvalid();
+        if (!firstError)
+            return;
+        const elementId = `question-${firstError.id}`;
+        this.retryCount = 0;
+        // Change page if needed
+        if (this.currentPageIndex !== firstError.pageIndex) {
+            this.currentPageIndex = firstError.pageIndex;
+            if (this.currentPageIndex + 1 < this.pageDetails.length) {
+                this.nextPage = this.pageDetails[this.currentPageIndex + 1];
+            }
+            if (this.currentPageIndex - 1 >= 0) {
+                this.previousPage = this.pageDetails[this.currentPageIndex - 1];
+            }
+            this.debounce(() => this.changeDetectorRef.detectChanges(), 100);
+            if (this.navigation === 'TAB')
+                this.child.triggerFunction(firstError.pageIndex);
+        }
+        await this.scrollToElementWithRetry(elementId);
+    }
+    async scrollToElementWithRetry(elementId) {
+        this.retryCount++;
+        const element = document.getElementById(elementId);
+        if (element) {
+            requestAnimationFrame(() => this.scrollAndFocus(element));
+            return;
+        }
+        if (this.retryCount < this.maxRetries) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            return this.scrollToElementWithRetry(elementId);
+        }
+        console.error(`Element ${elementId} not found after ${this.maxRetries} attempts`);
+        requestAnimationFrame(() => this.fallbackScroll());
+    }
+    scrollAndFocus(element) {
+        element.scrollIntoView({
+            behavior: 'smooth',
+            block: 'center',
+            inline: 'nearest',
+        });
+        const focusable = element.querySelector('input, select, textarea, button, [tabindex]:not([tabindex="-1"])');
+        focusable?.focus();
+    }
+    fallbackScroll() {
+        const pageElement = document.querySelector(`.page-${this.currentPageIndex}`);
+        pageElement?.scrollIntoView({ behavior: 'auto' });
+    }
+    debounce(func, delay) {
+        clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(func, delay);
+    }
+    //   extractId(message: string): string | null {
+    //     const match = message.match(/[0-9a-fA-F-]{36}/);
+    //     return match ? match[0] : null;
+    // }
+    //  removeId(message: string): string {
+    //   return message.replace(/[0-9a-fA-F-]{36}$/, "").trim();
+    // }
+    findQuestionPageIndex(questionErrors) {
+        for (let pageIndex = 0; pageIndex < this.pages.length; pageIndex++) {
+            const page = this.pages[pageIndex];
+            for (const row of page.rows) {
+                for (const element of row.grid) {
+                    this.checkAndStoreInvalidQuestions(element, questionErrors, pageIndex);
+                }
+            }
+        }
+    }
+    checkAndStoreInvalidQuestions(element, questionErrors, pageIndex) {
+        if (element.element.id && questionErrors.has(element.element.id)) {
+            this.validationService.setInvalid(element.element.id, questionErrors.get(element.element.id), pageIndex);
+        }
+        // Handle subforms recursively
+        if (element.entityType === 'SUBFORM' && element.element.rows) {
+            for (const row of element.element.rows) {
+                for (const gridItem of row.grid) {
+                    this.checkAndStoreInvalidQuestions(gridItem, questionErrors, pageIndex);
+                }
+            }
+        }
+        if ((element.entityType === 'QUESTION_GROUP' ||
+            element.entityType === 'MULTIFIELD') &&
+            element.element.rows) {
+            for (const row of element.element.rows) {
+                for (const gridItem of row.grid) {
+                    this.checkAndStoreInvalidQuestions(gridItem, questionErrors, pageIndex);
+                }
+            }
+        }
+        // Handle logic-based conditions recursively
+        if (element.entityType === 'QUESTION' && element.element.childLogics) {
+            for (const logic of element.element.childLogics) {
+                if (logic.showLogic) {
+                    for (const row of logic.rows) {
+                        for (const gridItem of row.grid) {
+                            this.checkAndStoreInvalidQuestions(gridItem, questionErrors, pageIndex);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    focusQuestionElement(container) {
+        // Find first focusable element within the question
+        const focusable = container.querySelector('input, select, textarea, [tabindex]');
+        if (focusable) {
+            focusable.focus();
+        }
+        else {
+            container.focus();
+        }
+    }
+    validateForm(jsonData) {
+        const validateQuestions = (formElements) => {
+            for (let element of formElements) {
+                if (element.entityType === 'QUESTION') {
+                    const required = element.element.required;
+                    const answer = element.element.answer;
+                    const validation = element.element.validation;
+                    const show = element.show;
+                    if (element.element.formElement.elementType === 'FILE_PICKER') {
+                        const attachment = element.element.attachments;
+                        if (required && show) {
+                            if ((!answer || answer?.length === 0) &&
+                                (!attachment || attachment?.length == 0)) {
+                                this.inValidQuestions.set(element.element.id, 'Required file question has no files uploaded.');
+                                return {
+                                    isValid: false,
+                                    message: `Form is invalid - Required file question ${element.element.questionNumber} has no files uploaded.`,
+                                    pageIndex: 0,
+                                };
+                            }
+                        }
+                    }
+                    else {
+                        if (required && show) {
+                            if (answer === null ||
+                                answer === undefined ||
+                                (typeof answer === 'string' && answer.trim() === '') ||
+                                (typeof answer === 'object' && Object.keys(answer).length === 0)) {
+                                this.inValidQuestions.set(element.element.id, 'This is a required question');
+                                return {
+                                    isValid: false,
+                                    message: `Form is invalid - Question ${element.element.questionNumber} is required but no answer provided.`,
+                                    pageIndex: 0,
+                                };
+                            }
+                            else if (validation === false) {
+                                this.inValidQuestions.set(element.element.id, element.element.validationMessage);
+                                return {
+                                    isValid: false,
+                                    message: `Form is invalid - Question ${element.element.questionNumber} is required but validation is false.`,
+                                    pageIndex: 0,
+                                };
+                            }
+                        }
+                        else if (!required && answer && Object.keys(answer).length > 0) {
+                            if (validation === false) {
+                                this.inValidQuestions.set(element.element.id, element.element.validationMessage);
+                                return {
+                                    isValid: false,
+                                    message: `Form is invalid - Question ${element.element.questionNumber} is not required but answer provided with validation false.`,
+                                    pageIndex: 0,
+                                };
+                            }
+                        }
+                    }
+                    if (element.element.childLogics) {
+                        for (let logic of element.element.childLogics) {
+                            if (logic.showLogic) {
+                                const result = validateQuestions(logic.rows);
+                                if (!result.isValid)
+                                    return result;
+                            }
+                        }
+                    }
+                }
+                else if (element.entityType === 'SUBFORM' && !element.element.deleted) {
+                    if (element.element.property?.subFormStructure == 'single') {
+                        for (let row of element.element.rows) {
+                            const result = validateQuestions(row.grid);
+                            if (!result.isValid)
+                                return result;
+                        }
+                    }
+                    else {
+                        this.validateSubForm(element);
+                    }
+                }
+                else if ((element.entityType === 'QUESTION_GROUP' ||
+                    element.entityType === 'MULTIFIELD') &&
+                    element.element.rows) {
+                    for (const row of element.element.rows) {
+                        const result = validateQuestions(row.grid);
+                        if (!result.isValid && element.entityType != 'MULTIFIELD')
+                            return result;
+                    }
+                }
+            }
+            return { isValid: true, message: '', pageIndex: 0 };
+        };
+        for (let pageIndex = 0; pageIndex < jsonData.length; pageIndex++) {
+            const page = jsonData[pageIndex];
+            for (let row of page.rows) {
+                const result = validateQuestions(row.grid);
+                this.inValidQuestions.forEach((message, id) => {
+                    this.validationService.setInvalid(id, message, pageIndex);
+                });
+                this.inValidQuestions = new Map();
+                // if (!result.isValid) {
+                //   return {
+                //     isValid: false,
+                //     message: `Page ${pageIndex + 1}: ${result.message}`,
+                //     pageIndex: pageIndex,
+                //   };
+                // }
+            }
+        }
+        this.currentPageIndex = jsonData.length - 1;
+        if (this.validationService.getFirstInvalid()) {
+            this.navigateToFirstError();
+            return {
+                isValid: false,
+                message: `Page`,
+                pageIndex: 0,
+            };
+        }
+        return {
+            isValid: true,
+            message: 'Form is valid.',
+            pageIndex: 0,
+        };
+    }
+    validateSubForm(element) {
+        if (element.entityType !== 'SUBFORM') {
+            return;
+        }
+        const submissions = element.element?.submissions || [];
+        /* ------------------------------
+         * 1️⃣ Subform required but no submission
+         * ------------------------------ */
+        if (element.element?.required && submissions.length === 0) {
+            this.inValidQuestions.set(element.element.id, 'At least one submission is required');
+            return; // nothing else to validate
+        }
+        submissions.forEach((submission, submissionIndex) => {
+            const answers = submission.answers || [];
+            /* ------------------------------
+             * 2️⃣ Submission exists but no answers
+             * ------------------------------ */
+            const hasAnyAnswer = answers.some((a) => a.answer !== null &&
+                a.answer !== undefined &&
+                a.answer !== '' &&
+                !(Array.isArray(a.answer) && a.answer.length === 0));
+            if (element.element?.required && !hasAnyAnswer) {
+                const key = `${element.element.id}`;
+                this.inValidQuestions.set(key, 'At least one answer is required in the subform');
+                return;
+            }
+            /* ------------------------------
+             * 3️⃣ Existing question-level validations
+             * ------------------------------ */
+            answers.forEach((answerObj) => {
+                const question = this.findQuestionById(element.element.rows, answerObj.questionId);
+                const ans = answerObj.answer;
+                // Required question check
+                if ((question?.required || answerObj.required) &&
+                    (ans === '' || ans === null || ans === undefined || ans?.length === 0)) {
+                    const key = `${submissionIndex}-${question.id}`;
+                    this.inValidQuestions.set(key, 'This is a required question');
+                }
+                // Email validation
+                if (question?.formElement?.elementType === 'EMAIL' && ans) {
+                    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                    if (!emailRegex.test(ans)) {
+                        const key = `${submissionIndex}-${question.id}`;
+                        this.inValidQuestions.set(key, 'Please enter a valid email address');
+                    }
+                }
+            });
+        });
+    }
+    // 🔍 Helper: find question definition inside rows
+    findQuestionById(rows, questionId) {
+        for (const row of rows) {
+            for (const gridElement of row.grid) {
+                if (gridElement.entityType === 'QUESTION' &&
+                    gridElement.element.id === questionId) {
+                    return gridElement.element;
+                }
+            }
+        }
+        return null;
+    }
+    updateSubFormWithSubmissions(event) {
+        this.updateSubForm(this.pages, event);
+    }
+    extractGroupedWebhookData(webhooks) {
+        const result = {
+            headers: {},
+            params: {},
+            pathVariables: {},
+            requestBodies: {},
+        };
+        for (const webhook of webhooks ?? []) {
+            for (const item of webhook?.headers ?? []) {
+                const value = this.getValueFromStorage(item.valueSource, item.inputValue);
+                if (value !== null) {
+                    result.headers[item.keyName] = value;
+                }
+            }
+            for (const item of webhook?.params ?? []) {
+                const value = this.getValueFromStorage(item.valueSource, item.inputValue);
+                if (value !== null) {
+                    result.params[item.keyName] = value;
+                }
+            }
+            for (const item of webhook?.pathVariables ?? []) {
+                const value = this.getValueFromStorage(item.valueSource, item.inputValue);
+                if (value !== null) {
+                    result.pathVariables[item.keyName] = value;
+                }
+            }
+            for (const item of webhook?.requestBodies ?? []) {
+                const value = this.getValueFromStorage(item.valueSource, item.inputValue);
+                if (value !== null) {
+                    result.requestBodies[item.keyName] = value;
+                }
+            }
+        }
+        return result;
+    }
+    getValueFromStorage(source, key) {
+        if (source === 'LOCAL_STORAGE')
+            return localStorage.getItem(key);
+        if (source === 'SESSION_STORAGE')
+            return sessionStorage.getItem(key);
+        return null;
+    }
+    cancelled() {
+        this.cancel.emit();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SubmitFormComponent, deps: [{ token: i1.FormService }, { token: i2.ToastrService }, { token: i3.Router }, { token: i4.DataService }, { token: i5.RecaptchaService }, { token: i6.ValidationService }, { token: i0.ChangeDetectorRef }, { token: i7.ElementTrackerService }, { token: i8.FormValidationService }, { token: i9.AggregationFunctionService }, { token: i10.ScoreCalculationService }, { token: i11.MatDialog }, { token: i12.WhenClauseService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: SubmitFormComponent, selector: "lib-submit-form", inputs: { moduleName: "moduleName", edit: "edit", submissionId: "submissionId", acceptedLanguage: "acceptedLanguage", skipMargin: "skipMargin", skipValidation: "skipValidation", navigateTo: "navigateTo", country: "country", showCancelButton: "showCancelButton", isActionTriggered: "isActionTriggered" }, outputs: { submit: "submit", apiCalled: "apiCalled", currentPageIndexChange: "currentPageIndexChange", cancel: "cancel" }, viewQueries: [{ propertyName: "child", first: true, predicate: NavigationTabsComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"outer-container\">\r\n\r\n<ng-container *ngIf=\"isLoadingPages\">\r\n    <ngx-skeleton-loader count=\"5\"></ngx-skeleton-loader>\r\n</ng-container>\r\n\r\n  <div class=\"head container\" *ngIf=\"!skipMargin\">\r\n    <lib-header [name]=\"name\" [skipMargin]=\"skipMargin\"></lib-header>\r\n  </div>\r\n\r\n\r\n\r\n  <div class=\"body\" [ngClass]=\"{ 'skip-margin': skipMargin,container: !skipMargin}\">\r\n\r\n    <lib-submission-container [parentQuestionAnswers]=\"parentQuestionAnswers\"\r\n    *ngIf=\"parentQuestionAnswers\"></lib-submission-container>\r\n\r\n    <lib-navigation-tabs\r\n      *ngIf=\"navigation == 'TAB'\"\r\n      [skipMargin]=\"skipMargin\"\r\n      [skipValidation]=\"skipValidation\"\r\n      [pages]=\"pages\"\r\n      [currentPageIndex]=\"currentPageIndex\"\r\n      (pageChanged)=\"setCurrentPage($event)\"\r\n      (submitEmit)=\"submitForm()\"\r\n      [pageDetails]=\"pageDetails\"\r\n      [eligibleForSubmission]=\"eligibleForSubmission\"\r\n      [edit]=\"edit\"\r\n      [acceptedLanguage] = \"acceptedLanguage\"\r\n      [isActionTriggered]=\"isActionTriggered\"\r\n      [primaryColor]=\"primaryColor\"\r\n      [secondaryColor]=\"secondaryColor\"\r\n      [markAllQuestionsAsRequired]=\"markAllQuestionsAsRequired\"\r\n      [submissionInProgress]=\"submissionInProgress\"\r\n      [submissionInDraft]=\"submissionInDraft\"\r\n      [showCancelButton]=\"showCancelButton\"\r\n      [submissionProgress]=\"submissionProgress\"\r\n      [animatedDots]=\"animatedDots\"\r\n      [currentStep]=\"currentStep\"\r\n      (saveAsDraftEmit)=\"saveAsDraft()\"\r\n      (subFormChange)=\"updateSubFormWithSubmissions($event)\"\r\n      (rowSetIndex)=\"loadMoreData($event)\"\r\n      (cancel)=\"cancelled()\"\r\n    ></lib-navigation-tabs>\r\n    <lib-next-prev-navigation\r\n      *ngIf=\"navigation == 'NEXT_AND_PREVIOUS_BUTTON'\"\r\n      [skipMargin]=\"skipMargin\"\r\n      [currentPageIndex]=\"currentPageIndex\"\r\n      [pageDetails]=\"pageDetails\"\r\n      (rowSetIndex)=\"loadMoreData($event)\"\r\n      [pages]=\"pages\"\r\n      [previousPage]=\"previousPage\"\r\n      [isActionTriggered]=\"isActionTriggered\"\r\n      [currentPage]=\"currentPage\"\r\n      [primaryColor]=\"primaryColor\"\r\n      [secondaryColor]=\"secondaryColor\"\r\n      [nextPage]=\"nextPage\"\r\n      (navigateNext)=\"navigateToNextPage()\"\r\n      (navigatePrevious)=\"navigateToPreviousPage()\"\r\n      [acceptedLanguage] = \"acceptedLanguage\"\r\n      (submitEmit)=\"submitForm()\"\r\n      (saveAsDraftEmit)=\"saveAsDraft()\"\r\n      [edit]=\"edit\"\r\n      [eligibleForSubmission]=\"eligibleForSubmission\"\r\n      [submissionInProgress]=\"submissionInProgress\"\r\n      [submissionInDraft]=\"submissionInDraft\"\r\n      [showCancelButton]=\"showCancelButton\"\r\n      [submissionProgress]=\"submissionProgress\"\r\n      [animatedDots]=\"animatedDots\"\r\n      [currentStep]=\"currentStep\"\r\n      (subFormChange)=\"updateSubFormWithSubmissions($event)\"\r\n      (cancel)=\"cancelled()\"\r\n       [skipValidation]=\"skipValidation\"\r\n    ></lib-next-prev-navigation>\r\n  </div>\r\n</div>\r\n", styles: [".outer-container{background-color:#fff;padding:20px;position:relative;margin-top:25px}@media (max-width: 576px){.outer-container{padding:8px}}.head{background-color:#fff;padding:0!important}.body{position:relative;z-index:1;background:#efefef;border-radius:6px}.skip-margin{background:#fff}.save-draft-wrapper{display:flex;justify-content:flex-end;gap:1rem;margin-top:1rem;margin-right:2rem;padding:0 1.5rem 1.5rem}.draft-btn{display:inline-flex;align-items:center;justify-content:center;gap:8px;padding:.65rem 1.6rem;font-size:14px;font-weight:500;border-radius:9999px;border:1px solid transparent;cursor:pointer;background:linear-gradient(135deg,#2563eb,#1d4ed8);color:#fff;transition:all .2s ease}.draft-btn:hover:not(:disabled){background:linear-gradient(135deg,#1e40af,#1d4ed8);transform:translateY(-1px);box-shadow:0 3px 6px #0000001a}.draft-btn:disabled{background:#cbd5e1;color:#64748b;cursor:not-allowed;box-shadow:none}.draft-btn .spinner{border:2px solid rgba(255,255,255,.3);border-top:2px solid #fff;border-radius:50%;width:14px;height:14px;animation:spin .6s linear infinite}@keyframes spin{to{transform:rotate(360deg)}}\n"], dependencies: [{ kind: "directive", type: i13.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i13.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i14.NgxSkeletonLoaderComponent, selector: "ngx-skeleton-loader", inputs: ["count", "loadingText", "appearance", "animation", "ariaLabel", "theme"] }, { kind: "component", type: i15.HeaderComponent, selector: "lib-header", inputs: ["name", "skipMargin"] }, { kind: "component", type: i16.NavigationTabsComponent, selector: "lib-navigation-tabs", inputs: ["pages", "currentPageIndex", "skipValidation", "edit", "acceptedLanguage", "eligibleForSubmission", "pageDetails", "markAllQuestionsAsRequired", "skipMargin", "primaryColor", "secondaryColor", "isActionTriggered", "submissionInProgress", "submissionInDraft", "showCancelButton", "submissionProgress", "currentStep", "animatedDots"], outputs: ["pageChanged", "submitEmit", "saveAsDraftEmit", "subFormChange", "rowSetIndex", "cancel"] }, { kind: "component", type: i17.NextPrevNavigationComponent, selector: "lib-next-prev-navigation", inputs: ["skipValidation", "currentPageIndex", "pages", "previousPage", "nextPage", "currentPage", "pageDetails", "skipMargin", "edit", "acceptedLanguage", "primaryColor", "secondaryColor", "isActionTriggered", "submissionInProgress", "submissionInDraft", "eligibleForSubmission", "showCancelButton", "submissionProgress", "currentStep", "animatedDots"], outputs: ["navigateNext", "navigatePrevious", "submitEmit", "saveAsDraftEmit", "cancel", "subFormChange", "rowSetIndex"] }, { kind: "component", type: i18.SubmissionContainerComponent, selector: "lib-submission-container", inputs: ["parentQuestionAnswers"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SubmitFormComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-submit-form', template: "<div class=\"outer-container\">\r\n\r\n<ng-container *ngIf=\"isLoadingPages\">\r\n    <ngx-skeleton-loader count=\"5\"></ngx-skeleton-loader>\r\n</ng-container>\r\n\r\n  <div class=\"head container\" *ngIf=\"!skipMargin\">\r\n    <lib-header [name]=\"name\" [skipMargin]=\"skipMargin\"></lib-header>\r\n  </div>\r\n\r\n\r\n\r\n  <div class=\"body\" [ngClass]=\"{ 'skip-margin': skipMargin,container: !skipMargin}\">\r\n\r\n    <lib-submission-container [parentQuestionAnswers]=\"parentQuestionAnswers\"\r\n    *ngIf=\"parentQuestionAnswers\"></lib-submission-container>\r\n\r\n    <lib-navigation-tabs\r\n      *ngIf=\"navigation == 'TAB'\"\r\n      [skipMargin]=\"skipMargin\"\r\n      [skipValidation]=\"skipValidation\"\r\n      [pages]=\"pages\"\r\n      [currentPageIndex]=\"currentPageIndex\"\r\n      (pageChanged)=\"setCurrentPage($event)\"\r\n      (submitEmit)=\"submitForm()\"\r\n      [pageDetails]=\"pageDetails\"\r\n      [eligibleForSubmission]=\"eligibleForSubmission\"\r\n      [edit]=\"edit\"\r\n      [acceptedLanguage] = \"acceptedLanguage\"\r\n      [isActionTriggered]=\"isActionTriggered\"\r\n      [primaryColor]=\"primaryColor\"\r\n      [secondaryColor]=\"secondaryColor\"\r\n      [markAllQuestionsAsRequired]=\"markAllQuestionsAsRequired\"\r\n      [submissionInProgress]=\"submissionInProgress\"\r\n      [submissionInDraft]=\"submissionInDraft\"\r\n      [showCancelButton]=\"showCancelButton\"\r\n      [submissionProgress]=\"submissionProgress\"\r\n      [animatedDots]=\"animatedDots\"\r\n      [currentStep]=\"currentStep\"\r\n      (saveAsDraftEmit)=\"saveAsDraft()\"\r\n      (subFormChange)=\"updateSubFormWithSubmissions($event)\"\r\n      (rowSetIndex)=\"loadMoreData($event)\"\r\n      (cancel)=\"cancelled()\"\r\n    ></lib-navigation-tabs>\r\n    <lib-next-prev-navigation\r\n      *ngIf=\"navigation == 'NEXT_AND_PREVIOUS_BUTTON'\"\r\n      [skipMargin]=\"skipMargin\"\r\n      [currentPageIndex]=\"currentPageIndex\"\r\n      [pageDetails]=\"pageDetails\"\r\n      (rowSetIndex)=\"loadMoreData($event)\"\r\n      [pages]=\"pages\"\r\n      [previousPage]=\"previousPage\"\r\n      [isActionTriggered]=\"isActionTriggered\"\r\n      [currentPage]=\"currentPage\"\r\n      [primaryColor]=\"primaryColor\"\r\n      [secondaryColor]=\"secondaryColor\"\r\n      [nextPage]=\"nextPage\"\r\n      (navigateNext)=\"navigateToNextPage()\"\r\n      (navigatePrevious)=\"navigateToPreviousPage()\"\r\n      [acceptedLanguage] = \"acceptedLanguage\"\r\n      (submitEmit)=\"submitForm()\"\r\n      (saveAsDraftEmit)=\"saveAsDraft()\"\r\n      [edit]=\"edit\"\r\n      [eligibleForSubmission]=\"eligibleForSubmission\"\r\n      [submissionInProgress]=\"submissionInProgress\"\r\n      [submissionInDraft]=\"submissionInDraft\"\r\n      [showCancelButton]=\"showCancelButton\"\r\n      [submissionProgress]=\"submissionProgress\"\r\n      [animatedDots]=\"animatedDots\"\r\n      [currentStep]=\"currentStep\"\r\n      (subFormChange)=\"updateSubFormWithSubmissions($event)\"\r\n      (cancel)=\"cancelled()\"\r\n       [skipValidation]=\"skipValidation\"\r\n    ></lib-next-prev-navigation>\r\n  </div>\r\n</div>\r\n", styles: [".outer-container{background-color:#fff;padding:20px;position:relative;margin-top:25px}@media (max-width: 576px){.outer-container{padding:8px}}.head{background-color:#fff;padding:0!important}.body{position:relative;z-index:1;background:#efefef;border-radius:6px}.skip-margin{background:#fff}.save-draft-wrapper{display:flex;justify-content:flex-end;gap:1rem;margin-top:1rem;margin-right:2rem;padding:0 1.5rem 1.5rem}.draft-btn{display:inline-flex;align-items:center;justify-content:center;gap:8px;padding:.65rem 1.6rem;font-size:14px;font-weight:500;border-radius:9999px;border:1px solid transparent;cursor:pointer;background:linear-gradient(135deg,#2563eb,#1d4ed8);color:#fff;transition:all .2s ease}.draft-btn:hover:not(:disabled){background:linear-gradient(135deg,#1e40af,#1d4ed8);transform:translateY(-1px);box-shadow:0 3px 6px #0000001a}.draft-btn:disabled{background:#cbd5e1;color:#64748b;cursor:not-allowed;box-shadow:none}.draft-btn .spinner{border:2px solid rgba(255,255,255,.3);border-top:2px solid #fff;border-radius:50%;width:14px;height:14px;animation:spin .6s linear infinite}@keyframes spin{to{transform:rotate(360deg)}}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.FormService }, { type: i2.ToastrService }, { type: i3.Router }, { type: i4.DataService }, { type: i5.RecaptchaService }, { type: i6.ValidationService }, { type: i0.ChangeDetectorRef }, { type: i7.ElementTrackerService }, { type: i8.FormValidationService }, { type: i9.AggregationFunctionService }, { type: i10.ScoreCalculationService }, { type: i11.MatDialog }, { type: i12.WhenClauseService }]; }, propDecorators: { moduleName: [{
+                type: Input
+            }], edit: [{
+                type: Input
+            }], submissionId: [{
+                type: Input
+            }], acceptedLanguage: [{
+                type: Input
+            }], skipMargin: [{
+                type: Input
+            }], skipValidation: [{
+                type: Input
+            }], navigateTo: [{
+                type: Input
+            }], country: [{
+                type: Input
+            }], submit: [{
+                type: Output
+            }], apiCalled: [{
+                type: Output
+            }], currentPageIndexChange: [{
+                type: Output
+            }], showCancelButton: [{
+                type: Input
+            }], cancel: [{
+                type: Output
+            }], child: [{
+                type: ViewChild,
+                args: [NavigationTabsComponent, { static: false }]
+            }], isActionTriggered: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"submit-form.component.js","sourceRoot":"","sources":["../../../../../projects/form-submission/src/form-submission/submit-form/submit-form.component.ts","../../../../../projects/form-submission/src/form-submission/submit-form/submit-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectorRef,\r\n  Component,\r\n  EventEmitter,\r\n  Input,\r\n  OnDestroy,\r\n  OnInit,\r\n  Output,\r\n  SimpleChanges,\r\n  ViewChild,\r\n} from '@angular/core';\r\nimport { FormService } from '../../services/form.service';\r\nimport * as mapper from '../../services/mapper.service';\r\nimport { PublicForm } from '../../models/publicForm.model';\r\nimport { ToastrService } from 'ngx-toastr';\r\nimport { Router } from '@angular/router';\r\nimport { DataService } from '../../services/data.service';\r\nimport { RecaptchaService } from '../../services/recaptcha.service';\r\nimport { ValidationService } from '../../services/validation.service';\r\nimport { ElementTrackerService } from '../../services/element-tracker.service';\r\nimport { NavigationTabsComponent } from '../navigation-tabs/navigation-tabs.component';\r\nimport { FormValidationService } from '../../services/form-validation.service';\r\nimport { AggregationFunctionService } from '../../services/aggregate.service';\r\nimport { EmitterDTO } from '../../models/emitters.model';\r\nimport { ScoreCalculationService } from '../../services/score.service';\r\nimport { MatDialog } from '@angular/material/dialog';\r\nimport { SaveDraftModalComponent } from '../save-as-draft/saveDraftModalComponent ';\r\nimport { WhenClauseService } from '../../services/whenClause.service';\r\nimport { HttpEventType } from '@angular/common/http';\r\n\r\ninterface Answer {\r\n  questionId: string;\r\n  answer: any;\r\n  answerId?: string;\r\n  deleteFiles?: string[];\r\n  fields?: any;\r\n}\r\n\r\ninterface Submission {\r\n  submissionId?: string;\r\n  answers: Answer[];\r\n}\r\n\r\ninterface Form {\r\n  formId: string;\r\n  deleted?: boolean;\r\n  deletedSubmissions: any[];\r\n  submissions: Submission[];\r\n  copiedForms: string[];\r\n  scores?:{\r\n    scoreType: string;\r\n    score: number;\r\n  }[];\r\n  maximumPossibleScore?:number;\r\n  show?:boolean;\r\n}\r\n\r\ninterface CopyForms{\r\n  id: string,\r\n  title: string,\r\n  description: string,\r\n  parentSubform: string,\r\n  questionRelation: Record<string, string>;\r\n}\r\n\r\ninterface WhenClauseElements{\r\n  elementId:string;\r\n  entityType:string;\r\n  show:boolean;\r\n}\r\n\r\ninterface QuestionAnswersWrapper {\r\n  parentId: string;\r\n  answers: Answer[];\r\n  forms: Form[];\r\n  copySubForms:CopyForms[];\r\n  scores?:{\r\n    scoreType: string;\r\n    score: number;\r\n  }[];\r\n  maximumPossibleScore?:number;\r\n  whenClauseElements: WhenClauseElements[]\r\n}\r\n\r\ninterface SubmissionScore {\r\n  scoreType: string;\r\n  score: number;\r\n}\r\n\r\n@Component({\r\n  selector: 'lib-submit-form',\r\n  templateUrl: './submit-form.component.html',\r\n  styleUrls: ['./submit-form.component.scss'],\r\n})\r\nexport class SubmitFormComponent implements OnInit, OnDestroy {\r\n  question: PublicForm | null = null;\r\n  @Input() moduleName: string = '';\r\n  @Input() edit: boolean = false;\r\n  @Input() submissionId: string = '';\r\n  @Input() acceptedLanguage: string = '';\r\n  @Input() skipMargin: boolean = false;\r\n  @Input() skipValidation: boolean = false;\r\n  @Input() navigateTo: string = '';\r\n  @Input() country: string = '';\r\n  @Output() submit: EventEmitter<any> = new EventEmitter<any>();\r\n  @Output() apiCalled: EventEmitter<boolean> = new EventEmitter<boolean>();\r\n  @Output() currentPageIndexChange: EventEmitter<number> =\r\n    new EventEmitter<number>();\r\n  @Input() showCancelButton: boolean = false;\r\n  @Output() cancel: EventEmitter<string> = new EventEmitter<string>();\r\n  @ViewChild(NavigationTabsComponent, { static: false })\r\n  child!: NavigationTabsComponent;\r\n  @Input() isActionTriggered: boolean = false;\r\n  isLoading: boolean = false;\r\n  name: string = '';\r\n  saveAutomatically: boolean = false;\r\n  saveInterval: number = 0;\r\n  customizeFont: boolean = false;\r\n  fontFamily: string = '';\r\n  fontSize: number = 0;\r\n  validationSkip: boolean = false;\r\n  enableDataExport: boolean = false;\r\n  fileFormats: string[] = [];\r\n  enableQuestionNumbering: boolean = false;\r\n  questionNumbering: string = '';\r\n  enableGoogleRecaptcha: boolean = false;\r\n  googleRecaptchaKey: string = '';\r\n  googleRecaptchaSecret: string = '';\r\n  navigation: string = '';\r\n  markAllQuestionsAsRequired: boolean = false;\r\n  pages: any = [];\r\n  currentPageIndex: number = 0;\r\n  previousPage: any = {};\r\n  currentPage: any = {};\r\n  nextPage: any = {};\r\n  lastTab: boolean = false;\r\n  questionAnswers: QuestionAnswersWrapper = {\r\n    parentId: '',\r\n    answers: [],\r\n    forms: [],\r\n    copySubForms: [],\r\n    whenClauseElements: []\r\n  };\r\n  webhook: any;\r\n  files: { questionId: string; file: any ; show?:boolean}[] = [];\r\n  parentQuestions: any;\r\n  submission: any = {};\r\n  parentQuestionAnswers: any;\r\n  parentSubmissionId: string = '';\r\n  submissionInProgress: boolean = false;\r\n  submissionInDraft: boolean = false;\r\n  recaptchaToken: string = '';\r\n  private isRefreshing: boolean = false;\r\n  private intervalId: ReturnType<typeof setInterval> | null = null;\r\n  pageDetails: any = [];\r\n  pageNumber: number = 1;\r\n  rowSet: number = 0;\r\n  rowSetCount: [number] = [0];\r\n  retryCount: number = 0;\r\n  maxRetries: number = 5;\r\n\r\n  eligibleForSubmission: { status: boolean; message: string } = {\r\n    status: true,\r\n    message: '',\r\n  };\r\n  webhookPayloadArray: any[] = [];\r\n  inValidQuestions: Map<string, string> = new Map<string, string>();\r\n  visitedRows: Map<number, number> = new Map<number, number>();\r\n  allElementIds: string[] = [];\r\n  private debounceTimer: any;\r\n  primaryColor: string = '#084fff';\r\n  secondaryColor: string = '';\r\n  isLoadingPages: boolean = false;\r\n  copySubforms: CopyForms[] = [];\r\n  emitters: EmitterDTO[] = [];\r\n  maxPossibleScore!: number;\r\n  maxPossibleGoodScore!: number;\r\n  maxPossibleBadScore!: number;\r\n  sumOfFindings!: number;\r\n  sumOfGoodFindings!: number;\r\n  sumOfBadFindings!: number;\r\n  draft: boolean = false;\r\n  submissionProgress = 0;\r\n  showSubmissionLoader = false;\r\n  progressInterval: any;\r\n  currentStep = 'Submitting form';\r\n  animatedDots = '';\r\n  private dotInterval: any;\r\n\r\n  constructor(\r\n    private formService: FormService,\r\n    private toastr: ToastrService,\r\n    private router: Router,\r\n    private dataService: DataService,\r\n    private recaptchaService: RecaptchaService,\r\n    private validationService: ValidationService,\r\n    private changeDetectorRef: ChangeDetectorRef,\r\n    private elementTracker: ElementTrackerService,\r\n    private formValidationService: FormValidationService,\r\n    private aggregateService: AggregationFunctionService,\r\n    private scoreCalcService: ScoreCalculationService,\r\n    public dialog: MatDialog,\r\n    private whenClauseService:WhenClauseService\r\n  ) {\r\n    const navigation = this.router.getCurrentNavigation();\r\n    this.submission = navigation?.extras.state?.['submission'];\r\n    this.parentSubmissionId = this.submission?.id;\r\n    this.parentQuestionAnswers = this.submission?.questionAnswers;\r\n    this.parentQuestions = navigation?.extras.state?.['parentQuestions'];\r\n    this.dataService.setParentQuestions(this.parentQuestions);\r\n  }\r\n  ngOnDestroy(): void {\r\n    this.visitedRows.clear();\r\n    this.recaptchaService.removeRecaptchaScript();\r\n    if (this.intervalId) {\r\n      clearInterval(this.intervalId);\r\n      this.intervalId = null;\r\n      this.isRefreshing = false;\r\n    }\r\n    this.aggregateService.clearAll();\r\n    this.recaptchaService.removeRecaptchaScript();\r\n    this.whenClauseService.resetService();\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes['acceptedLanguage']) {\r\n      this.currentPageIndex = 0;\r\n      this.acceptedLanguage = changes['acceptedLanguage'].currentValue;\r\n      if (!this.edit) this.getFormData();\r\n    }\r\n    if(changes['submissionId']){\r\n      this.submissionId=changes['submissionId'].currentValue;\r\n      if (this.edit && this.submissionId) {\r\n        this.getSubmittedFormData();\r\n      }\r\n    }\r\n  }\r\n\r\n  ngOnInit() {\r\n    if (this.edit && this.submissionId) {\r\n      // this.getSubmittedFormData();\r\n    } else {\r\n      // this.getFormData();\r\n    }\r\n\r\n    if (this.enableGoogleRecaptcha) {\r\n      this.recaptchaInitialized();\r\n    }\r\n  }\r\n\r\n  async recaptchaInitialized() {\r\n    await this.recaptchaService.initialize();\r\n    this.recaptchaService.render('captcha-container', (token) => {});\r\n  }\r\n\r\n  async getToken(): Promise<string> {\r\n    return new Promise(async (resolve) => {\r\n      try {\r\n        await this.recaptchaService.initialize();\r\n\r\n        // Check if CAPTCHA was rendered\r\n        if (!this.recaptchaService.isRendered()) {\r\n          console.warn('reCAPTCHA not rendered yet.');\r\n          return resolve('');\r\n        }\r\n\r\n        // If solved, return the token\r\n        if (this.recaptchaService.isResolved()) {\r\n          const token = this.recaptchaService.getResponse();\r\n\r\n          return resolve(token);\r\n        }\r\n\r\n        // If expired or unsolved, return empty string\r\n        console.warn('reCAPTCHA not resolved or expired.');\r\n        return resolve('');\r\n      } catch (err) {\r\n        console.error('reCAPTCHA initialization failed:', err);\r\n        return resolve('');\r\n      }\r\n    });\r\n  }\r\n\r\n  loadFont(fontName: string): void {\r\n    const fontPath = `assets/fonts/${fontName}.woff2`; // Adjust extension as per your font file\r\n    const style = document.createElement('style');\r\n    style.innerHTML = `\r\n      @font-face {\r\n        font-family: '${fontName}';\r\n        src: url('${fontPath}') format('woff2');\r\n        font-weight: normal;\r\n        font-style: normal;\r\n      }\r\n      body {\r\n        font-family: '${fontName}', sans-serif;\r\n      }\r\n    `;\r\n    document.head.appendChild(style);\r\n  }\r\n\r\n  getFormData() {\r\n    this.isLoadingPages = true;\r\n    this.formService\r\n      .getQuestions(this.moduleName, 1, 0, true,this.country)\r\n      .subscribe((response: any) => {\r\n        this.isLoadingPages = false;\r\n        this.enableGoogleRecaptcha =\r\n          response.result.moduleConfiguration?.enableGoogleRecaptcha;\r\n        this.question = mapper.mapPublicFormToModel(response);\r\n        this.emitters = this.question.emitters || [];\r\n        this.assignQuestionProperties(this.question);\r\n        this.setUpFontFamily(response);\r\n        this.primaryColor = response.result.primaryColor || '#084fff';\r\n        this.secondaryColor = response.result.secondaryColor;\r\n        if (this.enableGoogleRecaptcha) this.recaptchaInitialized();\r\n        if (response?.result?.pageDetails) {\r\n          this.pageDetails = response.result.pageDetails;\r\n          this.nextPage = this.pageDetails[1];\r\n        }\r\n        this.webhook = response?.result?.webhooks;\r\n        this.webhookPayloadArray = response?.result?.webhooks?.map(\r\n          (w: any) => ({\r\n            id: w.id,\r\n            ...this.extractGroupedWebhookData([w]),\r\n          })\r\n        );\r\n\r\n        this.rowSetCount[0] = response.result.totalNumberRow;\r\n        for (let i = 0; i < this.pageDetails.length; i++) {\r\n          if (!this.pages[i]) {\r\n            this.pages[i] = [];\r\n          }\r\n        }\r\n        this.checkSubmissionEligibility();\r\n      });\r\n  }\r\n\r\n  getSubmittedFormData() {\r\n    this.formService\r\n      .getSubmittedForm(\r\n        this.moduleName,\r\n        this.submissionId,\r\n        1,\r\n        0,\r\n        this.navigateTo\r\n      )\r\n      .subscribe((response) => {\r\n        this.enableGoogleRecaptcha =\r\n          response.result.moduleConfiguration.enableGoogleRecaptcha;\r\n        this.question = mapper.mapPublicFormToModel(response);\r\n        this.assignQuestionProperties(this.question);\r\n        this.primaryColor = response.result.primaryColor || '#084fff';\r\n        this.secondaryColor = response.result.secondaryColor;\r\n        this.emitters = this.question.emitters || [];\r\n        if (response?.result?.pageDetails) {\r\n          this.pageDetails = response.result.pageDetails;\r\n          this.nextPage = this.pageDetails[1];\r\n        }\r\n        this.webhookPayloadArray;\r\n        this.webhookPayloadArray = response?.result?.webhooks?.map(\r\n          (w: any) => ({\r\n            id: w.id,\r\n            ...this.extractGroupedWebhookData([w]),\r\n          })\r\n        );\r\n        this.rowSetCount[0] = response.result.totalNumberRow;\r\n        for (let i = 0; i < this.pageDetails.length; i++) {\r\n          if (!this.pages[i]) {\r\n            this.pages[i] = [];\r\n          }\r\n        }\r\n        this.setUpFontFamily(response);\r\n        if (this.navigateTo) {\r\n          setTimeout(() => {\r\n            this.navigateToFormElement();\r\n          });\r\n        }\r\n        if (this.enableGoogleRecaptcha) {\r\n          this.recaptchaInitialized();\r\n        }\r\n        this.checkSubmissionEligibility();\r\n      });\r\n  }\r\n\r\n  setUpFontFamily(response: any) {\r\n    //set font family and font size\r\n    if (response.result?.moduleConfiguration?.customizeFont) {\r\n      this.fontFamily = response.result.moduleConfiguration?.fontFamily;\r\n      this.fontSize = response.result.moduleConfiguration?.fontSize || 18;\r\n    } else {\r\n      this.fontFamily = 'Poppins';\r\n      this.fontSize = 18;\r\n    }\r\n    this.loadFont(this.fontFamily);\r\n    document.documentElement.style.setProperty(\r\n      '--library-font-family',\r\n      this.fontFamily\r\n    );\r\n    document.documentElement.style.setProperty(\r\n      '--library-font-size',\r\n      this.fontSize + 'px'\r\n    );\r\n  }\r\n\r\n  navigateToFormElement() {\r\n    if (!this.pages) return;\r\n\r\n    let foundPageIndex: number | null = null;\r\n\r\n    // Step 1: find the page index\r\n    this.pages.forEach((page: any, pageIndex: number) => {\r\n      if (!page?.rows) return;\r\n\r\n      page.rows.forEach((row: any) => {\r\n        if (!row?.grid) return;\r\n\r\n        row.grid.forEach((gridItem: any) => {\r\n          const element = gridItem?.element;\r\n          if (!element) return;\r\n\r\n          // Case 1: Direct question match\r\n          if (\r\n            gridItem.entityType === 'QUESTION' &&\r\n            element.id === this.navigateTo\r\n          ) {\r\n            foundPageIndex = pageIndex;\r\n          }\r\n\r\n          // Case 2: Subform match\r\n          if (gridItem.entityType === 'SUBFORM') {\r\n            if (element.id === this.navigateTo) {\r\n              foundPageIndex = pageIndex;\r\n            }\r\n            if (\r\n              element.submissions?.some(\r\n                (s: any) => s.submissionId === this.navigateTo\r\n              )\r\n            ) {\r\n              foundPageIndex = pageIndex;\r\n            }\r\n          }\r\n        });\r\n      });\r\n    });\r\n\r\n    if (foundPageIndex !== null) {\r\n      // Step 2: Set current page\r\n      this.currentPageIndex = foundPageIndex;\r\n      this.currentPage = this.pages[this.currentPageIndex];\r\n\r\n      if (this.navigation == 'TAB') {\r\n        this.child.triggerFunction(this.currentPageIndex);\r\n      } else {\r\n\r\n        this.previousPage = this.pageDetails[this.currentPageIndex - 1];\r\n        this.nextPage = this.pageDetails[this.currentPageIndex + 1];\r\n      }\r\n      // Step 3: Wait for DOM render and scroll\r\n      setTimeout(() => {\r\n        const elementId = `question-${this.navigateTo}`;\r\n        const el = document.getElementById(elementId);\r\n        if (el) {\r\n          el.scrollIntoView({ behavior: 'smooth', block: 'center' });\r\n          this.checkSubmissionEligibility();\r\n        }\r\n      }, 0);\r\n    } else {\r\n      console.warn(`navigateTo id ${this.navigateTo} not found in any page`);\r\n    }\r\n  }\r\n\r\n  assignQuestionProperties(question: PublicForm) {\r\n    this.name = question.name;\r\n    this.pages = question.pages;\r\n    if (this.parentQuestions) {\r\n      this.parentQuestionAnswers = question?.questionAnswers;\r\n      this.parentSubmissionId = question?.parentId;\r\n    }\r\n    this.currentPage = this.pages[0];\r\n    this.nextPage = this.pages[1];\r\n    this.saveAutomatically = question.formConfiguration.saveAutomatically;\r\n    this.saveInterval = question.formConfiguration.saveInterval;\r\n    this.customizeFont = question.formConfiguration.customizeFont;\r\n    this.fontFamily = question.formConfiguration.fontFamily;\r\n    this.fontSize = question.formConfiguration.fontSize;\r\n    this.enableDataExport = question.formConfiguration.enableDataExport;\r\n    this.fileFormats = question.formConfiguration.fileFormats;\r\n    this.enableQuestionNumbering =\r\n      question.formConfiguration.enableQuestionNumbering;\r\n    this.questionNumbering = question.formConfiguration.questionNumbering;\r\n    this.enableGoogleRecaptcha =\r\n      question.formConfiguration.enableGoogleRecaptcha;\r\n    this.googleRecaptchaKey = question.formConfiguration.googleRecaptchaKey;\r\n    this.googleRecaptchaSecret =\r\n      question.formConfiguration.googleRecaptchaSecret;\r\n    this.navigation = question.formConfiguration.navigation;\r\n    this.markAllQuestionsAsRequired =\r\n      question.formConfiguration.markAllQuestionsAsRequired;\r\n    this.apiCalled.emit(true);\r\n  }\r\n\r\n  navigateToNextPage() {\r\n    if (!this.isLoading) {\r\n      this.isLoading = true;\r\n      const nextIndex = this.currentPageIndex + 1;\r\n      if (nextIndex < this.pageDetails.length) {\r\n        if (this.markAllQuestionsAsRequired) {\r\n          const currentPageData = this.pages[this.currentPageIndex];\r\n          let validationResponse = true;\r\n          if (!this.validationSkip) {\r\n            validationResponse =\r\n              this.formValidationService.validateRequiredQuestions(\r\n                currentPageData\r\n              ).isValid;\r\n          }\r\n          if (validationResponse) {\r\n            this.previousPage = this.pageDetails[this.currentPageIndex];\r\n            if (this.pages[nextIndex].length != 0) {\r\n              this.currentPage = this.pages[nextIndex];\r\n              this.currentPageIndex = nextIndex;\r\n            } else {\r\n              this.setCurrentPage(nextIndex);\r\n            }\r\n            this.nextPage = this.pageDetails[nextIndex + 1];\r\n          }\r\n        } else {\r\n          this.previousPage = this.pageDetails[this.currentPageIndex];\r\n          if (this.pages[nextIndex].length != 0) {\r\n            this.currentPage = this.pages[nextIndex];\r\n            this.currentPageIndex = nextIndex;\r\n          } else {\r\n            this.setCurrentPage(nextIndex);\r\n          }\r\n          this.nextPage = this.pageDetails[nextIndex + 1];\r\n        }\r\n      }\r\n      this.isLoading = false;\r\n      this.checkSubmissionEligibility();\r\n    }\r\n  }\r\n\r\n  navigateToPreviousPage() {\r\n    if (this.currentPageIndex > 0) {\r\n      if (this.markAllQuestionsAsRequired) {\r\n        const currentPageData = this.pages[this.currentPageIndex];\r\n        let validationResponse = true;\r\n        if (!this.validationSkip) {\r\n          validationResponse =\r\n            this.formValidationService.validateRequiredQuestions(\r\n              currentPageData\r\n            ).isValid;\r\n        }\r\n        if (validationResponse) {\r\n          this.nextPage = this.pageDetails[this.currentPageIndex];\r\n          this.currentPageIndex--;\r\n          if (this.pages[this.currentPageIndex].length != 0) {\r\n            this.currentPage = this.pages[this.currentPageIndex];\r\n          } else {\r\n            this.setCurrentPage(this.currentPageIndex);\r\n          }\r\n          this.previousPage = this.pageDetails[this.currentPageIndex - 1];\r\n        }\r\n      } else {\r\n        this.nextPage = this.pageDetails[this.currentPageIndex];\r\n        this.currentPageIndex--;\r\n        if (this.pages[this.currentPageIndex].length != 0) {\r\n          this.currentPage = this.pages[this.currentPageIndex];\r\n        } else {\r\n          this.setCurrentPage(this.currentPageIndex);\r\n        }\r\n        this.previousPage = this.pageDetails[this.currentPageIndex - 1];\r\n      }\r\n    }\r\n    this.checkSubmissionEligibility();\r\n  }\r\n\r\n  checkSubmissionEligibility(): void {\r\n    this.eligibleForSubmission = this.validateAllElementLoaded();\r\n  }\r\n\r\n  setCurrentPage(index: number) {\r\n    if (index < this.pages.length) {\r\n      // If page already exists AND has content → no need to fetch again\r\n      if (\r\n        this.pages[index] &&\r\n        this.pages[index].rows &&\r\n        this.pages[index].rows.length > 0\r\n      ) {\r\n        this.checkSubmissionEligibility();\r\n        return;\r\n      }\r\n    }\r\n    this.pageNumber = index + 1;\r\n    if (this.edit) {\r\n      this.formService\r\n        .getSubmittedForm(\r\n          this.moduleName,\r\n          this.submissionId,\r\n          this.pageNumber,\r\n          this.rowSet\r\n        )\r\n        .subscribe((response: any) => {          \r\n          const mappedResponse = mapper.mapPageToModel(response.result.pages[0],response.result?.currency,response.result?.defaultCurrency);\r\n          if (mappedResponse) {\r\n            this.pages[index] = mappedResponse;\r\n          }\r\n          this.currentPageIndex = index;\r\n          this.currentPage = this.pages[index];\r\n          this.rowSetCount[index] = response.result.totalNumberRow;\r\n          this.checkSubmissionEligibility();\r\n        });\r\n    } else {\r\n      this.formService\r\n        .getQuestions(this.moduleName, this.pageNumber, this.rowSet, true,this.country)\r\n        .subscribe((response: any) => {\r\n          const mappedResponse = mapper.mapPageToModel(response.result.pages[0],response.result?.currency,response.result?.defaultCurrency);\r\n          if (mappedResponse) {\r\n            this.pages[index] = mappedResponse;\r\n          }\r\n          this.currentPageIndex = index;\r\n          this.currentPage = this.pages[index];\r\n          this.rowSetCount[index] = response.result.totalNumberRow;\r\n          this.checkSubmissionEligibility();\r\n        });\r\n    }\r\n\r\n    if (this.markAllQuestionsAsRequired) {\r\n      const currentPageData = this.pages[this.currentPageIndex];\r\n      let validationResponse = true;\r\n      if (!this.validationSkip) {\r\n        validationResponse =\r\n          this.formValidationService.validateRequiredQuestions(\r\n            currentPageData\r\n          ).isValid;\r\n      }\r\n      if (validationResponse) {\r\n        this.currentPageIndex = index;\r\n      } else {\r\n        this.checkSubmissionEligibility();\r\n        return;\r\n      }\r\n    } else {\r\n      this.checkSubmissionEligibility();\r\n      this.currentPageIndex = index;\r\n    }\r\n  }\r\n\r\n  loadMoreData(index: number): void {\r\n    if (!this.isLoading) {\r\n      this.isLoading = true;\r\n      let rowCountLimit = this.rowSetCount[index];\r\n      let i = 0;\r\n      this.pages[index].rows.forEach((row: any) => {\r\n        row.grid.forEach((gridItem: any) => {\r\n          i++;\r\n        });\r\n      });\r\n      let rowCount = i / 20;\r\n      rowCount = Math.ceil(rowCount);\r\n\r\n      if (this.visitedRows.has(index)) {\r\n        if (this.visitedRows.get(index) === rowCount) {\r\n          this.isLoading = false;\r\n          return;\r\n        }\r\n      }\r\n\r\n      if (rowCount + 1 > rowCountLimit && !this.navigateTo) {\r\n        this.checkSubmissionEligibility();\r\n        this.isLoading = false;\r\n        return;\r\n      }\r\n      this.visitedRows.set(index, rowCount);\r\n\r\n      if (this.edit) {\r\n        this.formService\r\n          .getSubmittedForm(\r\n            this.moduleName,\r\n            this.submissionId,\r\n            index + 1,\r\n            rowCount\r\n          )\r\n          .subscribe((response: any) => {\r\n            const newRows = response?.result?.pages[0]?.rows ?? [];\r\n            this.pages[index].rows = [\r\n              ...(this.pages[index]?.rows ?? []),\r\n              ...newRows,\r\n            ];\r\n            this.currentPageIndex = index;\r\n            this.currentPage = this.pages[index];\r\n            this.rowSetCount[index] = response.result.totalNumberRow;\r\n            this.checkSubmissionEligibility();\r\n            this.isLoading = false;\r\n          });\r\n      } else {\r\n        this.formService\r\n          .getQuestions(this.moduleName, index + 1, rowCount)\r\n          .subscribe((response: any) => {\r\n            const newRows = response?.result?.pages[0]?.rows ?? [];\r\n            this.pages[index].rows = [\r\n              ...(this.pages[index]?.rows ?? []),\r\n              ...newRows,\r\n            ];\r\n            this.currentPageIndex = index;\r\n            this.currentPage = this.pages[index];\r\n            this.rowSetCount[index] = response.result.totalNumberRow;\r\n            this.checkSubmissionEligibility();\r\n            this.isLoading = false;\r\n          });\r\n      }\r\n\r\n      this.checkSubmissionEligibility();\r\n    }\r\n  }\r\n\r\n  generateQuestionAnswers() {\r\n    this.maxPossibleScore = 1;\r\n    this.sumOfFindings = 0;\r\n    this.sumOfBadFindings = 0;\r\n    this.sumOfGoodFindings = 0;\r\n    this.maxPossibleBadScore = 0;\r\n    this.maxPossibleGoodScore = 0;\r\n    this.copySubforms = [];\r\n\r\n    // this.maxPossibleGoodScore = 0;\r\n    // this.maxPossibleBadScore = 0;\r\n    const extractQuestions = (\r\n      formElements: any[],\r\n      parentFormId: string | null = null,\r\n      isInSubForm: boolean = false,\r\n      subFormIndex: number = 0\r\n    ): { answers: Answer[]; forms: Form[] } => {\r\n      const questions: Answer[] = [];\r\n      const forms: Form[] = [];\r\n      formElements.forEach((element) => {\r\n        if (element.entityType === 'QUESTION' && element.show) {\r\n          let baseQuestion: any;\r\n          if (element.element.formElement.elementType === 'FILE_PICKER') {\r\n            baseQuestion = {\r\n              questionId: element.element.id,\r\n              answer: '',\r\n            };\r\n            if (Array.isArray(element.element.answer)) {\r\n              const questionId = isInSubForm\r\n                ? `${parentFormId}_${subFormIndex}_${element.element.id}`\r\n                : element.element.id;\r\n              this.files.push({\r\n                questionId: questionId,\r\n                file: element.element.answer,\r\n                show: element.show\r\n              });\r\n            }\r\n          } else {\r\n            baseQuestion = {\r\n              questionId: element.element.id,\r\n              answer: element.element.answer,\r\n              score: element.element.score,\r\n              maximumPossibleScore: element.element.maxPossibleScore,\r\n              currencySymbol: element.element?.currencySymbol,\r\n              amountInWords: element.element?.amountInWords,\r\n              show: element.show\r\n            };\r\n          }\r\n          if (this.edit) {\r\n            questions.push({\r\n              ...baseQuestion,\r\n              answerId: element.element.answerId || '',\r\n              deleteFiles: element.element.deleteFiles || [],\r\n            });\r\n          } else {\r\n            questions.push(baseQuestion);\r\n          }\r\n\r\n          if (\r\n            (element.element.formElement.elementType === 'DROP_DOWN' ||\r\n              element.element.formElement.elementType === 'RADIO_BUTTON' ||\r\n              element.element.formElement.elementType === 'CHECK_BOX') &&\r\n            element.element.formElement.scoring &&\r\n            element.element.formElement.scoring.enableScoring &&\r\n            !isInSubForm\r\n          ) {\r\n            this.maxPossibleScore *=\r\n              this.scoreCalcService.getMaxPossibleScoreForQuestion(\r\n                element.element\r\n              );\r\n            if (\r\n              element.element.score &&\r\n              element.element.score != null &&\r\n              element.element.score != undefined\r\n            ) {\r\n              this.sumOfFindings += element.element.score;\r\n            }\r\n          }\r\n\r\n          if (element.element.childLogics) {\r\n            for (let logic of element.element.childLogics) {\r\n              if (logic.showLogic) {\r\n                for (let row of logic.rows) {\r\n                  const result = extractQuestions(\r\n                    row.grid,\r\n                    parentFormId,\r\n                    isInSubForm,\r\n                    subFormIndex\r\n                  );\r\n                  questions.push(...result.answers);\r\n                  forms.push(...result.forms);\r\n                }\r\n              }\r\n            }\r\n          }\r\n        } else if (element.entityType === 'SUBFORM' && element.show) {\r\n          const subformId = element.element.id;\r\n          const submissionId = element.element.submissionId;\r\n          if (element.element.copySubformMeta) {\r\n            this.copySubforms.push(element.element.copySubformMeta);\r\n          }\r\n          if (element.element.property.subFormStructure === 'single') {\r\n            let allAnswers: Answer[] = [];\r\n\r\n            element.element.rows.forEach((row: any) => {\r\n              const extracted = extractQuestions(\r\n                row.grid,\r\n                subformId,\r\n                true,\r\n                forms.length\r\n              );\r\n              extracted.answers.forEach((answer) => {\r\n                allAnswers.push({ ...answer });\r\n              });\r\n            });\r\n            let copiedForms;\r\n            if (element.element.copiedForms) {\r\n              copiedForms = element.element.copiedForms;\r\n            }\r\n            const subform: Form = {\r\n              formId: subformId,\r\n              deleted: element.element.deleted,\r\n              deletedSubmissions: [],\r\n              submissions: [\r\n                {\r\n                  submissionId: submissionId,\r\n                  answers: allAnswers,\r\n                },\r\n              ],\r\n              copiedForms: copiedForms,\r\n            };\r\n\r\n            forms.push(subform);\r\n          } else if (element.element.property.subFormStructure === 'multiple') {\r\n            const subformAnswers: Answer[] = [];\r\n            let subformQuestions: any = { answers: [] };\r\n            element.element.rows.forEach((row: any) => {\r\n              subformQuestions = extractQuestions(\r\n                row.grid,\r\n                subformId,\r\n                true,\r\n                forms.length\r\n              );\r\n            });\r\n            const existingSubform = forms.find(\r\n              (form) => form.formId === subformId\r\n            );\r\n            if (\r\n              (element.element.property.subFormType == 'inline' ||\r\n                element.element.property.subFormType == 'card') &&\r\n              element.element.submissions\r\n            ) {\r\n              element.element.submissions = this.clearEmptySubmissions(\r\n                element.element.submissions\r\n              );\r\n            }\r\n            element.element?.submissions?.forEach(\r\n              (submission: any, index: number) => {\r\n                for (const s of submission.scores ?? []) {\r\n                  if (s.scoreType === 'GOOD_SCORE') {\r\n                    this.sumOfGoodFindings += s.score;\r\n                  }\r\n                  if (s.scoreType === 'BAD_SCORE') {\r\n                    this.sumOfBadFindings += s.score;\r\n                  }\r\n                }\r\n                delete submission.hasAllScoringAnsweredOnce;\r\n                submission.answers.forEach((answer: any) => {\r\n                  delete answer.htmlContent;\r\n                  if (Array.isArray(answer.files)) {\r\n                    const questionId = `${subformId}_${index}_${answer.questionId}`;\r\n                    this.files.push({\r\n                      questionId: questionId,\r\n                      file: answer.files,\r\n                    });\r\n                    delete answer.files;\r\n                  }\r\n                  delete answer.attachments;\r\n                });\r\n              }\r\n            );\r\n            let copiedForms;\r\n            if (element.element.copiedForms) {\r\n              copiedForms = element.element.copiedForms;\r\n            }\r\n\r\n            const subform: Form = {\r\n              formId: subformId,\r\n              deleted: element.element.deleted,\r\n              scores: element.element.scores,\r\n              deletedSubmissions: element.element.deletedSubmissions,\r\n              submissions: element.element.submissions,\r\n              copiedForms: copiedForms,\r\n            };\r\n            forms.push(subform);\r\n            this.maxPossibleScore +=\r\n              element.element?.maxPossibleScore *\r\n              element.element?.submissions?.length;\r\n            this.maxPossibleGoodScore +=\r\n              element.element?.maxPossibleScore?.good *\r\n              element.element?.submissions?.length || 0;\r\n            this.maxPossibleBadScore +=\r\n              element.element?.maxPossibleScore?.bad *\r\n              element.element?.submissions?.length || 0;\r\n          }\r\n        } else if (element.entityType === 'QUESTION_GROUP' && element.show) {\r\n          // Handle Question Group by iterating through rows\r\n          element.element.rows.forEach((row: any) => {\r\n            row.grid.forEach((gridItem: any) => {\r\n              if (gridItem.entityType === 'QUESTION' && gridItem.show) {\r\n                let baseQuestion: any;\r\n                if (\r\n                  gridItem.element?.formElement.elementType === 'FILE_PICKER'\r\n                ) {\r\n                  baseQuestion = {\r\n                    questionId: gridItem.element.id,\r\n                    answer: '',\r\n                  };\r\n                  if (Array.isArray(gridItem.element.answer)) {\r\n                    const questionId = isInSubForm\r\n                      ? `${parentFormId}_${subFormIndex}_${gridItem.element.id}`\r\n                      : gridItem.element.id;\r\n                    this.files.push({\r\n                      questionId: questionId,\r\n                      file: gridItem.element.answer,\r\n                    });\r\n                  }\r\n                } else {\r\n                  baseQuestion = {\r\n                    questionId: gridItem.element.id,\r\n                    answer: gridItem.element.answer,\r\n                    amountInWords: gridItem.element.amountInWords\r\n                  };\r\n                }\r\n                if (this.edit) {\r\n                  questions.push({\r\n                    ...baseQuestion,\r\n                    answerId: gridItem.element.answerId || '',\r\n                    deleteFiles: gridItem.element.deleteFiles || [],\r\n                  });\r\n                } else {\r\n                  questions.push(baseQuestion);\r\n                }\r\n\r\n                if (gridItem.element.childLogics) {\r\n                  for (let logic of gridItem.element.childLogics) {\r\n                    if (logic.showLogic) {\r\n                      for (let row of logic.rows) {\r\n                        const result = extractQuestions(\r\n                          row.grid,\r\n                          parentFormId,\r\n                          isInSubForm,\r\n                          subFormIndex\r\n                        );\r\n                        questions.push(...result.answers);\r\n                        forms.push(...result.forms);\r\n                      }\r\n                    }\r\n                  }\r\n                }\r\n              }\r\n            });\r\n          });\r\n        } else if (element.entityType === 'MULTIFIELD' && element.show) {\r\n          element.element.rows.forEach((row: any) => {\r\n            row.grid.forEach((gridItem: any) => {\r\n              if (gridItem.entityType === 'QUESTION' && gridItem.show) {\r\n                questions.push({\r\n                  questionId: gridItem.element.id,\r\n                  answer: gridItem.element.answer || '',\r\n                });\r\n              }\r\n            });\r\n          });\r\n        }\r\n      });\r\n      return { answers: questions, forms: forms };\r\n    };\r\n\r\n    const processPages = (\r\n      pages: any[]\r\n    ): { answers: Answer[]; forms: Form[] } => {\r\n      const questions: Answer[] = [];\r\n      const forms: Form[] = [];\r\n\r\n      pages.forEach((page) => {\r\n        page.rows.forEach((row: any) => {\r\n          const result = extractQuestions(row.grid);\r\n          questions.push(...result.answers);\r\n          forms.push(...result.forms);\r\n        });\r\n      });\r\n\r\n      return { answers: questions, forms: forms };\r\n    };\r\n    const result = processPages(this.pages);\r\n    const grids = this.whenClauseService.getActiveWhenClauseGrids();\r\n    const simplified = grids.map(grid => ({\r\n      elementId: grid?.element?.id ?? null,\r\n      entityType: grid?.entityType ?? null,\r\n      show: grid?.show ?? false\r\n    }));\r\n    this.questionAnswers = {\r\n      parentId: '',\r\n      answers: result.answers,\r\n      forms: result.forms,\r\n      copySubForms: this.copySubforms,\r\n      whenClauseElements: simplified\r\n    };\r\n  }\r\n\r\n  clearEmptySubmissions(submissions: any) {\r\n    const nonEmptySubmissions: Submission[] = [];\r\n    const emptySubmissionIds: string[] = [];\r\n\r\n    submissions.forEach((submission: any) => {\r\n      const hasValue = submission.answers.some(\r\n        (answer: any) =>\r\n          answer.answer !== '' &&\r\n          answer.answer !== null &&\r\n          answer.answer !== undefined\r\n      );\r\n      if (hasValue) {\r\n        nonEmptySubmissions.push(submission);\r\n      } else if (submission.submissionId) {\r\n        emptySubmissionIds.push(submission.submissionId);\r\n      }\r\n    });\r\n\r\n    submissions = nonEmptySubmissions;\r\n    return submissions;\r\n  }\r\n\r\n  validateAllElementLoaded(): { status: boolean; message: string } {\r\n    if (this.pages.length < this.pageDetails.length) {\r\n      return {\r\n        status: false,\r\n        message:\r\n          'Please ensure all pages are fully visible before submitting the form.',\r\n      };\r\n    }\r\n\r\n    const incompletePages: string[] = [];\r\n\r\n    this.pages.forEach((p: any, i: number) => {\r\n      if (p && Array.isArray(p.rows)) {\r\n        let j = 0;\r\n        p.rows.forEach((row: any) => {\r\n          row.grid.forEach((gridItem: any) => {\r\n            j++;\r\n          });\r\n        });\r\n        if (\r\n          !p ||\r\n          !Array.isArray(p.rows) ||\r\n          (Math.ceil(j / 20) != this.rowSetCount[i] && !this.navigateTo)\r\n        ) {\r\n          incompletePages.push(this.pageDetails[i].name);\r\n        }\r\n      } else {\r\n        incompletePages.push(this.pageDetails[i].name);\r\n      }\r\n    });\r\n\r\n    if (incompletePages.length > 0) {\r\n      return {\r\n        status: false,\r\n        message: `Some sections are still loading. Please scroll through the following pages to ensure all questions are loaded: ${incompletePages.join(\r\n          ', '\r\n        )}.`,\r\n      };\r\n    }\r\n\r\n    return {\r\n      status: true,\r\n      message: 'Great! All sections are complete. You can now submit the form.',\r\n    };\r\n  }\r\n  saveasDraftPopup(): void {\r\n    if (!this.skipValidation) {\r\n      return;\r\n    }\r\n    const dialogRef = this.dialog.open(SaveDraftModalComponent, {\r\n      width: '450px',\r\n      panelClass: 'custom-dialog-container',\r\n      autoFocus: false,\r\n      disableClose: true,\r\n      data: {\r\n        primaryColor: this.primaryColor,\r\n      },\r\n    });\r\n\r\n    dialogRef.afterClosed().subscribe((result) => {\r\n      if (result) {\r\n        this.validationSkip = true;\r\n        this.submitForm();\r\n      } else {\r\n        this.validationSkip = false;\r\n      }\r\n    });\r\n  }\r\n\r\n  saveAsDraft() {\r\n    this.validationSkip = true;\r\n    this.draft = true;\r\n    this.submitForm();\r\n  }\r\n\r\n  async submitForm() {\r\n    this.startSubmissionLoader();\r\n    if (this.webhook) {\r\n      this.webhookPayloadArray = this.webhook.map((w: any) => ({\r\n        id: w.id,\r\n        ...this.extractGroupedWebhookData([w]),\r\n      }));\r\n    }\r\n    if (!this.validateAllElementLoaded().status) {\r\n      this.toastr.warning('Please wait for all elements to load');\r\n      this.submit.emit({\r\n        status: 'failed',\r\n      });\r\n      return;\r\n    }\r\n    if (this.submissionInProgress || this.submissionInDraft) {\r\n      this.submit.emit({\r\n        status: 'failed',\r\n      });\r\n      return;\r\n    }\r\n    let recaptchaToken: string | undefined;\r\n    this.inValidQuestions.clear();\r\n    this.validationService.clearAll();\r\n    if (this.enableGoogleRecaptcha) {\r\n      try {\r\n        recaptchaToken = await this.getToken();\r\n\r\n        if (!recaptchaToken) {\r\n          this.toastr.error(\r\n            'Please complete the CAPTCHA verification before submitting the form.'\r\n          );\r\n          this.submissionInProgress = false;\r\n          this.submissionInDraft = false;\r\n          this.resetSubmissionLoader();\r\n          this.validationSkip = false;\r\n          this.draft = false;\r\n          this.submit.emit({\r\n            status: 'failed',\r\n          });\r\n          return;\r\n        }\r\n      } catch (error: any) {\r\n        console.error(\r\n          'Error while getting reCAPTCHA token:',\r\n          error.error?.message\r\n        );\r\n        this.toastr.error('Failed to verify reCAPTCHA.');\r\n        this.submissionInProgress = false;\r\n        this.submissionInDraft = false;\r\n        this.resetSubmissionLoader();\r\n        this.validationSkip = false;\r\n        this.draft = false;\r\n        this.submit.emit({\r\n          status: 'failed',\r\n        });\r\n        return;\r\n      }\r\n    }\r\n\r\n    if (this.draft || this.validationSkip) {\r\n      this.submissionInDraft = true;\r\n    } else {\r\n      this.submissionInProgress = true;\r\n    }\r\n\r\n    let validationResponse = true;\r\n    if (!this.validationSkip) {\r\n      validationResponse = this.validateForm(this.pages).isValid;\r\n    }\r\n\r\n    if (!validationResponse) {\r\n      this.saveasDraftPopup();\r\n      this.submissionInProgress = false;\r\n      this.submissionInDraft = false;\r\n      this.resetSubmissionLoader();\r\n      this.validationSkip = false;\r\n      this.draft = false;\r\n      this.submit.emit({\r\n        status: 'failed',\r\n      });\r\n      return;\r\n    }\r\n    const getCircularReplacer = () => {\r\n      const seen = new WeakSet();\r\n      return (_key: string, value: any) => {\r\n        if (typeof value === 'object' && value !== null) {\r\n          if (seen.has(value)) {\r\n            return undefined;\r\n          }\r\n          seen.add(value);\r\n        }\r\n        return value;\r\n      };\r\n    };\r\n\r\n    this.generateQuestionAnswers();\r\n    const formFinalScore = this.calculateFormFinalScore();\r\n    this.questionAnswers.scores = formFinalScore;\r\n    if (validationResponse) {\r\n      const formData = new FormData();\r\n      formData.append('skipValidation', this.validationSkip ? 'true' : 'false');\r\n      this.questionAnswers.parentId = this.parentSubmissionId;\r\n      formData.append(\r\n        'json',\r\n        JSON.stringify(this.questionAnswers, getCircularReplacer())\r\n      );\r\n      if (this.webhookPayloadArray) {\r\n        formData.append(\r\n          'webhookPayload',\r\n          JSON.stringify(this.webhookPayloadArray)\r\n        );\r\n      } else {\r\n        formData.append('webhookPayload', JSON.stringify([]));\r\n      }\r\n      if (this.files.length > 0) {\r\n        const seenQuestionIds = new Set<string>();\r\n\r\n        const uniqueFiles = this.files.filter((fileItem) => {\r\n          if (seenQuestionIds.has(fileItem.questionId)) {\r\n            return false;\r\n          }\r\n          seenQuestionIds.add(fileItem.questionId);\r\n          return true;\r\n        });\r\n\r\n        uniqueFiles.forEach((fileItem) => {\r\n          fileItem.file.forEach((file: any) => {\r\n            formData.append(fileItem.questionId, file._file);\r\n          });\r\n        });\r\n      }\r\n      const formServiceCall =\r\n        this.edit && this.submissionId\r\n          ? this.formService.updateForm(\r\n              this.moduleName,\r\n              this.submissionId,\r\n              formData,\r\n              recaptchaToken ?? ''\r\n            )\r\n          : this.formService.submitForm(\r\n              this.moduleName,\r\n              formData,\r\n              recaptchaToken ?? ''\r\n            );\r\n\r\n      formServiceCall.subscribe({\r\n        next: (event) => {\r\n          if (event.type === HttpEventType.UploadProgress) {\r\n            if (event.total) {\r\n              const percentDone = Math.round((event.loaded / event.total) * 100);\r\n              this.setProgress(Math.min(95, percentDone));\r\n            }\r\n          }\r\n      \r\n          if (event.type === HttpEventType.Response) {\r\n            this.completeSubmissionLoader();\r\n      \r\n            const response = event.body;\r\n      \r\n            // existing success logic ↓\r\n            this.toastr.success(\r\n              this.edit\r\n                ? 'Form updated successfully'\r\n                : 'Form submitted successfully'\r\n            );\r\n            let emittingValues;\r\n            if (this.emitters) {\r\n              emittingValues = this.mapEmittersToValues();\r\n            }\r\n  \r\n            if (this.validationSkip || this.draft) {\r\n              this.submit.emit({\r\n                status: 'draft',\r\n                submissionId: response.result,\r\n                score: formFinalScore,\r\n                ...(emittingValues || {}),\r\n              });\r\n            } else {\r\n              this.submit.emit({\r\n                status: 'success',\r\n                submissionId: response.result,\r\n                score: formFinalScore,\r\n                ...(emittingValues || {}),\r\n              });\r\n            }\r\n            this.submissionInProgress = false;\r\n            this.submissionInDraft = false;\r\n            this.draft = false;\r\n            this.validationSkip = false;\r\n          }\r\n        },\r\n        error: (error) => {\r\n          this.validationService.clearAll();\r\n          this.findQuestionPageIndex(\r\n            this.parseErrorsToMap(error.error.message)\r\n          );\r\n          this.currentPageIndex = this.pages.length - 1;\r\n          this.navigateToFirstError();\r\n          this.resetSubmissionLoader();\r\n          this.submissionInProgress = false;\r\n          this.draft = false;\r\n          this.validationSkip = false;\r\n          this.submissionInDraft = false;\r\n          this.saveasDraftPopup();\r\n          this.submit.emit({\r\n            status: 'failed',\r\n            message: error.error.message\r\n          });\r\n        },\r\n      });\r\n    } else {\r\n      // this.toastr.error(validationResponse.message);\r\n      this.submit.emit({\r\n        status: 'failed',\r\n      });\r\n      this.saveasDraftPopup();\r\n      this.submissionInProgress = false;\r\n      this.submissionInDraft = false;\r\n      this.resetSubmissionLoader();\r\n      this.validationSkip = false;\r\n      this.draft = false;\r\n    }\r\n  }\r\n\r\nsetProgress(value: number) {\r\n  this.submissionProgress = value;\r\n  this.updateStepText(value);\r\n}\r\n\r\n\r\nstartSubmissionLoader() {\r\n  this.showSubmissionLoader = true;\r\n  this.setProgress(0);\r\n\r\n  // Simulated progress until backend upload updates it\r\n  this.progressInterval = setInterval(() => {\r\n    if (this.submissionProgress < 85) {\r\n      this.setProgress(this.submissionProgress + 2);\r\n    }\r\n  }, 300);\r\n}\r\n\r\ncompleteSubmissionLoader() {\r\n  clearInterval(this.progressInterval);\r\n\r\n  this.setProgress(100);\r\n\r\n  setTimeout(() => {\r\n    this.showSubmissionLoader = false;\r\n    this.setProgress(0);\r\n  }, 500);\r\n}\r\n\r\nresetSubmissionLoader() {\r\n  clearInterval(this.progressInterval);\r\n\r\n  this.showSubmissionLoader = false;\r\n  clearInterval(this.dotInterval);\r\n  this.animatedDots = '';\r\n  this.setProgress(0);\r\n}\r\n\r\n\r\nstartTextLoader() {\r\n  let dotCount = 0;\r\n\r\n  this.dotInterval = setInterval(() => {\r\n    dotCount = (dotCount + 1) % 4;\r\n    this.animatedDots = '.'.repeat(dotCount);\r\n  }, 500);\r\n}\r\n\r\nupdateStepText(progress: number) {\r\n  if (progress < 25) {\r\n    this.currentStep = 'Validating form';\r\n  } else if (progress < 60) {\r\n    this.currentStep = 'Uploading data';\r\n  } else if (progress < 90) {\r\n    this.currentStep = 'Saving submission';\r\n  } else {\r\n    this.currentStep = 'Finalizing';\r\n  }\r\n}\r\n\r\n  calculateFormFinalScore(): SubmissionScore[] {\r\n    const goodScore = this.maxPossibleGoodScore\r\n      ? 100 - (this.sumOfGoodFindings / this.maxPossibleGoodScore) * 100\r\n      : 0;\r\n\r\n    const badScore = this.maxPossibleBadScore\r\n      ? 100 - (this.sumOfBadFindings / this.maxPossibleBadScore) * 100\r\n      : 0;\r\n\r\n    return [\r\n      { scoreType: 'GOOD_SCORE', score: Math.round(goodScore) },\r\n      { scoreType: 'BAD_SCORE', score: Math.round(badScore) },\r\n    ];\r\n  }\r\n\r\n  mapEmittersToValues(): { [key: string]: any } {\r\n    const answerMap = new Map(\r\n      this.questionAnswers.answers.map((qa) => [qa.questionId, qa.answer])\r\n    );\r\n\r\n    const result: { [key: string]: any } = {};\r\n\r\n    this.emitters.forEach((emitter) => {\r\n      if (emitter.valueSource === 'CUSTOM_INPUT') {\r\n        result[emitter.keyName] = emitter.inputValue;\r\n      } else if (\r\n        emitter.valueSource === 'QUESTION' &&\r\n        emitter.questionId &&\r\n        answerMap.has(emitter.questionId)\r\n      ) {\r\n        result[emitter.keyName] = answerMap.get(emitter.questionId);\r\n      }\r\n    });\r\n\r\n    return result;\r\n  }\r\n\r\n  parseErrorsToMap(errorString: string): Map<string, string> {\r\n    const errorMap = new Map<string, string>();\r\n    // Convert the incorrect format to a valid object structure\r\n    errorString\r\n      .replace(/[{}]/g, '') // Remove curly braces\r\n      .split(', ') // Split key-value pairs\r\n      .forEach((pair) => {\r\n        const [key, value] = pair.split('=');\r\n        if (key && value) {\r\n          errorMap.set(key.trim(), value.trim()); // Store in Map\r\n        }\r\n      });\r\n\r\n    return errorMap;\r\n  }\r\n  async navigateToFirstError() {\r\n    const firstError = this.validationService.getFirstInvalid();\r\n    if (!firstError) return;\r\n\r\n    const elementId = `question-${firstError.id}`;\r\n\r\n    this.retryCount = 0;\r\n\r\n    // Change page if needed\r\n    if (this.currentPageIndex !== firstError.pageIndex) {\r\n      this.currentPageIndex = firstError.pageIndex;\r\n      if (this.currentPageIndex + 1 < this.pageDetails.length) {\r\n        this.nextPage = this.pageDetails[this.currentPageIndex + 1];\r\n      }\r\n      if (this.currentPageIndex - 1 >= 0) {\r\n        this.previousPage = this.pageDetails[this.currentPageIndex - 1];\r\n      }\r\n\r\n      this.debounce(() => this.changeDetectorRef.detectChanges(), 100);\r\n      if (this.navigation === 'TAB')\r\n        this.child.triggerFunction(firstError.pageIndex);\r\n    }\r\n\r\n    await this.scrollToElementWithRetry(elementId);\r\n  }\r\n\r\n  private async scrollToElementWithRetry(elementId: string): Promise<void> {\r\n    this.retryCount++;\r\n    const element = document.getElementById(elementId);\r\n\r\n    if (element) {\r\n      requestAnimationFrame(() => this.scrollAndFocus(element));\r\n      return;\r\n    }\r\n\r\n    if (this.retryCount < this.maxRetries) {\r\n      await new Promise((resolve) => setTimeout(resolve, 100));\r\n      return this.scrollToElementWithRetry(elementId);\r\n    }\r\n\r\n    console.error(\r\n      `Element ${elementId} not found after ${this.maxRetries} attempts`\r\n    );\r\n    requestAnimationFrame(() => this.fallbackScroll());\r\n  }\r\n\r\n  private scrollAndFocus(element: HTMLElement) {\r\n    element.scrollIntoView({\r\n      behavior: 'smooth',\r\n      block: 'center',\r\n      inline: 'nearest',\r\n    });\r\n\r\n    const focusable = element.querySelector(\r\n      'input, select, textarea, button, [tabindex]:not([tabindex=\"-1\"])'\r\n    ) as HTMLElement;\r\n    focusable?.focus();\r\n  }\r\n\r\n  private fallbackScroll() {\r\n    const pageElement = document.querySelector(\r\n      `.page-${this.currentPageIndex}`\r\n    );\r\n    pageElement?.scrollIntoView({ behavior: 'auto' });\r\n  }\r\n\r\n  private debounce(func: () => void, delay: number) {\r\n    clearTimeout(this.debounceTimer);\r\n    this.debounceTimer = setTimeout(func, delay);\r\n  }\r\n  //   extractId(message: string): string | null {\r\n  //     const match = message.match(/[0-9a-fA-F-]{36}/);\r\n  //     return match ? match[0] : null;\r\n  // }\r\n\r\n  //  removeId(message: string): string {\r\n  //   return message.replace(/[0-9a-fA-F-]{36}$/, \"\").trim();\r\n  // }\r\n\r\n  findQuestionPageIndex(questionErrors: Map<string, string>): void {\r\n    for (let pageIndex = 0; pageIndex < this.pages.length; pageIndex++) {\r\n      const page = this.pages[pageIndex];\r\n\r\n      for (const row of page.rows) {\r\n        for (const element of row.grid) {\r\n          this.checkAndStoreInvalidQuestions(\r\n            element,\r\n            questionErrors,\r\n            pageIndex\r\n          );\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  private checkAndStoreInvalidQuestions(\r\n    element: any,\r\n    questionErrors: Map<string, string>,\r\n    pageIndex: number\r\n  ): void {\r\n    if (element.element.id && questionErrors.has(element.element.id)) {\r\n      this.validationService.setInvalid(\r\n        element.element.id,\r\n        questionErrors.get(element.element.id)!,\r\n        pageIndex\r\n      );\r\n    }\r\n\r\n    // Handle subforms recursively\r\n    if (element.entityType === 'SUBFORM' && element.element.rows) {\r\n      for (const row of element.element.rows) {\r\n        for (const gridItem of row.grid) {\r\n          this.checkAndStoreInvalidQuestions(\r\n            gridItem,\r\n            questionErrors,\r\n            pageIndex\r\n          );\r\n        }\r\n      }\r\n    }\r\n    if (\r\n      (element.entityType === 'QUESTION_GROUP' ||\r\n        element.entityType === 'MULTIFIELD') &&\r\n      element.element.rows\r\n    ) {\r\n      for (const row of element.element.rows) {\r\n        for (const gridItem of row.grid) {\r\n          this.checkAndStoreInvalidQuestions(\r\n            gridItem,\r\n            questionErrors,\r\n            pageIndex\r\n          );\r\n        }\r\n      }\r\n    }\r\n\r\n    // Handle logic-based conditions recursively\r\n    if (element.entityType === 'QUESTION' && element.element.childLogics) {\r\n      for (const logic of element.element.childLogics) {\r\n        if (logic.showLogic) {\r\n          for (const row of logic.rows) {\r\n            for (const gridItem of row.grid) {\r\n              this.checkAndStoreInvalidQuestions(\r\n                gridItem,\r\n                questionErrors,\r\n                pageIndex\r\n              );\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  focusQuestionElement(container: HTMLElement) {\r\n    // Find first focusable element within the question\r\n    const focusable = container.querySelector(\r\n      'input, select, textarea, [tabindex]'\r\n    );\r\n    if (focusable) {\r\n      (focusable as HTMLElement).focus();\r\n    } else {\r\n      container.focus();\r\n    }\r\n  }\r\n  validateForm(jsonData: any): {\r\n    isValid: boolean;\r\n    message: string;\r\n    pageIndex: number | 0;\r\n  } {\r\n    const validateQuestions = (\r\n      formElements: any[]\r\n    ): { isValid: boolean; message: string; pageIndex: number | 0 } => {\r\n      for (let element of formElements) {\r\n        if (element.entityType === 'QUESTION') {\r\n          const required = element.element.required;\r\n          const answer = element.element.answer;\r\n          const validation = element.element.validation;\r\n          const show = element.show;\r\n          if (element.element.formElement.elementType === 'FILE_PICKER') {\r\n            const attachment = element.element.attachments;\r\n            if (required && show) {\r\n              if (\r\n                (!answer || answer?.length === 0) &&\r\n                (!attachment || attachment?.length == 0)\r\n              ) {\r\n                this.inValidQuestions.set(\r\n                  element.element.id,\r\n                  'Required file question has no files uploaded.'\r\n                );\r\n                return {\r\n                  isValid: false,\r\n                  message: `Form is invalid - Required file question ${element.element.questionNumber} has no files uploaded.`,\r\n                  pageIndex: 0,\r\n                };\r\n              }\r\n            }\r\n          } else {\r\n            if (required && show) {\r\n              if (\r\n                answer === null ||\r\n                answer === undefined ||\r\n                (typeof answer === 'string' && answer.trim() === '') ||\r\n                (typeof answer === 'object' && Object.keys(answer).length === 0)\r\n              ) {\r\n                this.inValidQuestions.set(\r\n                  element.element.id,\r\n                  'This is a required question'\r\n                );\r\n                return {\r\n                  isValid: false,\r\n                  message: `Form is invalid - Question ${element.element.questionNumber} is required but no answer provided.`,\r\n                  pageIndex: 0,\r\n                };\r\n              } else if (validation === false) {\r\n                this.inValidQuestions.set(\r\n                  element.element.id,\r\n                  element.element.validationMessage\r\n                );\r\n                return {\r\n                  isValid: false,\r\n                  message: `Form is invalid - Question ${element.element.questionNumber} is required but validation is false.`,\r\n                  pageIndex: 0,\r\n                };\r\n              }\r\n            } else if (!required && answer && Object.keys(answer).length > 0) {\r\n              if (validation === false) {\r\n                this.inValidQuestions.set(\r\n                  element.element.id,\r\n                  element.element.validationMessage\r\n                );\r\n                return {\r\n                  isValid: false,\r\n                  message: `Form is invalid - Question ${element.element.questionNumber} is not required but answer provided with validation false.`,\r\n                  pageIndex: 0,\r\n                };\r\n              }\r\n            }\r\n          }\r\n          if (element.element.childLogics) {\r\n            for (let logic of element.element.childLogics) {\r\n              if (logic.showLogic) {\r\n                const result = validateQuestions(logic.rows);\r\n                if (!result.isValid) return result;\r\n              }\r\n            }\r\n          }\r\n        } else if (element.entityType === 'SUBFORM' && !element.element.deleted) {\r\n          if(element.element.property?.subFormStructure == 'single'){\r\n            for(let row of element.element.rows){\r\n              const result = validateQuestions(row.grid);\r\n              if (!result.isValid) return result;\r\n            }\r\n          } else {\r\n            this.validateSubForm(element);\r\n          }\r\n        } else if (\r\n          (element.entityType === 'QUESTION_GROUP' ||\r\n            element.entityType === 'MULTIFIELD') &&\r\n          element.element.rows\r\n        ) {\r\n          for (const row of element.element.rows) {\r\n            const result = validateQuestions(row.grid);\r\n            if (!result.isValid && element.entityType != 'MULTIFIELD')\r\n              return result;\r\n          }\r\n        }\r\n      }\r\n      return { isValid: true, message: '', pageIndex: 0 };\r\n    };\r\n\r\n    for (let pageIndex = 0; pageIndex < jsonData.length; pageIndex++) {\r\n      const page = jsonData[pageIndex];\r\n      for (let row of page.rows) {\r\n        const result = validateQuestions(row.grid);\r\n        this.inValidQuestions.forEach((message: string, id: string) => {\r\n          this.validationService.setInvalid(id, message, pageIndex);\r\n        });\r\n        this.inValidQuestions = new Map<string, string>();\r\n        // if (!result.isValid) {\r\n        //   return {\r\n        //     isValid: false,\r\n        //     message: `Page ${pageIndex + 1}: ${result.message}`,\r\n        //     pageIndex: pageIndex,\r\n        //   };\r\n        // }\r\n      }\r\n    }\r\n    this.currentPageIndex = jsonData.length - 1;\r\n    if (this.validationService.getFirstInvalid()) {\r\n      this.navigateToFirstError();\r\n      return {\r\n        isValid: false,\r\n        message: `Page`,\r\n        pageIndex: 0,\r\n      };\r\n    }\r\n    return {\r\n      isValid: true,\r\n      message: 'Form is valid.',\r\n      pageIndex: 0,\r\n    };\r\n  }\r\n\r\n  validateSubForm(element: any) {\r\n    if (element.entityType !== 'SUBFORM') {\r\n      return;\r\n    }\r\n  \r\n    const submissions = element.element?.submissions || [];\r\n  \r\n    /* ------------------------------\r\n     * 1️⃣ Subform required but no submission\r\n     * ------------------------------ */\r\n    if (element.element?.required && submissions.length === 0) {\r\n      this.inValidQuestions.set(\r\n        element.element.id,\r\n        'At least one submission is required'\r\n      );\r\n      return; // nothing else to validate\r\n    }\r\n  \r\n    submissions.forEach((submission: any, submissionIndex: number) => {\r\n      const answers = submission.answers || [];\r\n  \r\n      /* ------------------------------\r\n       * 2️⃣ Submission exists but no answers\r\n       * ------------------------------ */\r\n      const hasAnyAnswer = answers.some(\r\n        (a: any) =>\r\n          a.answer !== null &&\r\n          a.answer !== undefined &&\r\n          a.answer !== '' &&\r\n          !(Array.isArray(a.answer) && a.answer.length === 0)\r\n      );\r\n  \r\n      if (element.element?.required && !hasAnyAnswer) {\r\n        const key = `${element.element.id}`;\r\n        this.inValidQuestions.set(\r\n          key,\r\n          'At least one answer is required in the subform'\r\n        );\r\n        return;\r\n      }\r\n  \r\n      /* ------------------------------\r\n       * 3️⃣ Existing question-level validations\r\n       * ------------------------------ */\r\n      answers.forEach((answerObj: any) => {\r\n        const question = this.findQuestionById(\r\n          element.element.rows,\r\n          answerObj.questionId\r\n        );\r\n  \r\n        const ans = answerObj.answer;\r\n  \r\n        // Required question check\r\n        if ((question?.required || answerObj.required) &&\r\n            (ans === '' || ans === null || ans === undefined || ans?.length === 0)) {\r\n          const key = `${submissionIndex}-${question.id}`;\r\n          this.inValidQuestions.set(key, 'This is a required question');\r\n        }\r\n  \r\n        // Email validation\r\n        if (question?.formElement?.elementType === 'EMAIL' && ans) {\r\n          const emailRegex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;\r\n          if (!emailRegex.test(ans)) {\r\n            const key = `${submissionIndex}-${question.id}`;\r\n            this.inValidQuestions.set(\r\n              key,\r\n              'Please enter a valid email address'\r\n            );\r\n          }\r\n        }\r\n      });\r\n    });\r\n  }\r\n  \r\n\r\n  // 🔍 Helper: find question definition inside rows\r\n  private findQuestionById(rows: any[], questionId: string): any {\r\n    for (const row of rows) {\r\n      for (const gridElement of row.grid) {\r\n        if (\r\n          gridElement.entityType === 'QUESTION' &&\r\n          gridElement.element.id === questionId\r\n        ) {\r\n          return gridElement.element;\r\n        }\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  updateSubFormWithSubmissions(event: any) {\r\n    this.updateSubForm(this.pages, event);\r\n  }\r\n\r\n  updateSubForm = (pages: any[], updatedSubForm: any) => {\r\n    pages.forEach((page) => {\r\n      page.rows.forEach((row: any) => {\r\n        row.grid.forEach((element: any) => {\r\n          if (\r\n            element.entityType === 'SUBFORM' &&\r\n            element.element.id === updatedSubForm.id\r\n          ) {\r\n            // Update the existing subform with the new data\r\n            element.element = updatedSubForm;\r\n          } else if (\r\n            element.entityType === 'SUBFORM' &&\r\n            element.element.id !== updatedSubForm.formId\r\n          ) {\r\n            // Handle multiple subforms logic here if needed\r\n          } else if (\r\n            element.entityType === 'QUESTION' &&\r\n            element.element.childLogics\r\n          ) {\r\n            // Recursively update child logics\r\n            // element.element.childLogics.forEach((logic: any) => {\r\n            //   if (logic.showLogic) {\r\n            //     this.updateSubForm(logic.rows, updatedSubForm);\r\n            //   }\r\n            // });\r\n          }\r\n        });\r\n      });\r\n    });\r\n  };\r\n\r\n  extractGroupedWebhookData(webhooks: any[]): {\r\n    headers: Record<string, string>;\r\n    params: Record<string, string>;\r\n    pathVariables: Record<string, string>;\r\n    requestBodies: Record<string, string>;\r\n  } {\r\n    const result: {\r\n      headers: Record<string, string>;\r\n      params: Record<string, string>;\r\n      pathVariables: Record<string, string>;\r\n      requestBodies: Record<string, string>;\r\n    } = {\r\n      headers: {},\r\n      params: {},\r\n      pathVariables: {},\r\n      requestBodies: {},\r\n    };\r\n\r\n    for (const webhook of webhooks ?? []) {\r\n      for (const item of webhook?.headers ?? []) {\r\n        const value = this.getValueFromStorage(item.valueSource, item.inputValue);\r\n        if (value !== null) {\r\n          result.headers[item.keyName] = value;\r\n        }\r\n      }\r\n\r\n      for (const item of webhook?.params ?? []) {\r\n        const value = this.getValueFromStorage(item.valueSource, item.inputValue);\r\n        if (value !== null) {\r\n          result.params[item.keyName] = value;\r\n        }\r\n      }\r\n\r\n      for (const item of webhook?.pathVariables ?? []) {\r\n        const value = this.getValueFromStorage(item.valueSource, item.inputValue);\r\n        if (value !== null) {\r\n          result.pathVariables[item.keyName] = value;\r\n        }\r\n      }\r\n\r\n      for (const item of webhook?.requestBodies ?? []) {\r\n        const value = this.getValueFromStorage(item.valueSource, item.inputValue);\r\n        if (value !== null) {\r\n          result.requestBodies[item.keyName] = value;\r\n        }\r\n      }\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  getValueFromStorage(\r\n    source: 'LOCAL_STORAGE' | 'SESSION_STORAGE',\r\n    key: string\r\n  ): string | null {\r\n    if (source === 'LOCAL_STORAGE') return localStorage.getItem(key);\r\n    if (source === 'SESSION_STORAGE') return sessionStorage.getItem(key);\r\n    return null;\r\n  }\r\n\r\n  cancelled(){\r\n    this.cancel.emit();\r\n  }\r\n}\r\n","<div class=\"outer-container\">\r\n\r\n<ng-container *ngIf=\"isLoadingPages\">\r\n    <ngx-skeleton-loader count=\"5\"></ngx-skeleton-loader>\r\n</ng-container>\r\n\r\n  <div class=\"head container\" *ngIf=\"!skipMargin\">\r\n    <lib-header [name]=\"name\" [skipMargin]=\"skipMargin\"></lib-header>\r\n  </div>\r\n\r\n\r\n\r\n  <div class=\"body\" [ngClass]=\"{ 'skip-margin': skipMargin,container: !skipMargin}\">\r\n\r\n    <lib-submission-container [parentQuestionAnswers]=\"parentQuestionAnswers\"\r\n    *ngIf=\"parentQuestionAnswers\"></lib-submission-container>\r\n\r\n    <lib-navigation-tabs\r\n      *ngIf=\"navigation == 'TAB'\"\r\n      [skipMargin]=\"skipMargin\"\r\n      [skipValidation]=\"skipValidation\"\r\n      [pages]=\"pages\"\r\n      [currentPageIndex]=\"currentPageIndex\"\r\n      (pageChanged)=\"setCurrentPage($event)\"\r\n      (submitEmit)=\"submitForm()\"\r\n      [pageDetails]=\"pageDetails\"\r\n      [eligibleForSubmission]=\"eligibleForSubmission\"\r\n      [edit]=\"edit\"\r\n      [acceptedLanguage] = \"acceptedLanguage\"\r\n      [isActionTriggered]=\"isActionTriggered\"\r\n      [primaryColor]=\"primaryColor\"\r\n      [secondaryColor]=\"secondaryColor\"\r\n      [markAllQuestionsAsRequired]=\"markAllQuestionsAsRequired\"\r\n      [submissionInProgress]=\"submissionInProgress\"\r\n      [submissionInDraft]=\"submissionInDraft\"\r\n      [showCancelButton]=\"showCancelButton\"\r\n      [submissionProgress]=\"submissionProgress\"\r\n      [animatedDots]=\"animatedDots\"\r\n      [currentStep]=\"currentStep\"\r\n      (saveAsDraftEmit)=\"saveAsDraft()\"\r\n      (subFormChange)=\"updateSubFormWithSubmissions($event)\"\r\n      (rowSetIndex)=\"loadMoreData($event)\"\r\n      (cancel)=\"cancelled()\"\r\n    ></lib-navigation-tabs>\r\n    <lib-next-prev-navigation\r\n      *ngIf=\"navigation == 'NEXT_AND_PREVIOUS_BUTTON'\"\r\n      [skipMargin]=\"skipMargin\"\r\n      [currentPageIndex]=\"currentPageIndex\"\r\n      [pageDetails]=\"pageDetails\"\r\n      (rowSetIndex)=\"loadMoreData($event)\"\r\n      [pages]=\"pages\"\r\n      [previousPage]=\"previousPage\"\r\n      [isActionTriggered]=\"isActionTriggered\"\r\n      [currentPage]=\"currentPage\"\r\n      [primaryColor]=\"primaryColor\"\r\n      [secondaryColor]=\"secondaryColor\"\r\n      [nextPage]=\"nextPage\"\r\n      (navigateNext)=\"navigateToNextPage()\"\r\n      (navigatePrevious)=\"navigateToPreviousPage()\"\r\n      [acceptedLanguage] = \"acceptedLanguage\"\r\n      (submitEmit)=\"submitForm()\"\r\n      (saveAsDraftEmit)=\"saveAsDraft()\"\r\n      [edit]=\"edit\"\r\n      [eligibleForSubmission]=\"eligibleForSubmission\"\r\n      [submissionInProgress]=\"submissionInProgress\"\r\n      [submissionInDraft]=\"submissionInDraft\"\r\n      [showCancelButton]=\"showCancelButton\"\r\n      [submissionProgress]=\"submissionProgress\"\r\n      [animatedDots]=\"animatedDots\"\r\n      [currentStep]=\"currentStep\"\r\n      (subFormChange)=\"updateSubFormWithSubmissions($event)\"\r\n      (cancel)=\"cancelled()\"\r\n       [skipValidation]=\"skipValidation\"\r\n    ></lib-next-prev-navigation>\r\n  </div>\r\n</div>\r\n"]}