@piserve-tech/form-submission 1.3.317 → 1.3.319

package/esm2022/services/form.service.mjs

@@ -0,0 +1,332 @@
+import { Injectable } from '@angular/core';
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./data.service";
+export class FormService {
+    constructor(http, dataService) {
+        this.http = http;
+        this.dataService = dataService;
+        this.apiUrl = '';
+        this.header = {};
+        this.dataService.apiUrl$.subscribe((data) => {
+            this.apiUrl = data;
+        });
+        this.dataService.header$.subscribe((data) => {
+            this.header = data;
+        });
+        this.dataService.parentQuestions$.subscribe((questions) => {
+            if (questions) {
+                this.parentQuestions = questions;
+            }
+        });
+        this.dataService.subform$.subscribe((data) => {
+            this.subformData = data;
+        });
+    }
+    getQuestions(moduleName, pageNumber = 1, rowSet = 0, progressiveLoading = true, country = '') {
+        const headers = new HttpHeaders(this.getSafeHeaders());
+        const params = new HttpParams()
+            .set('pageNumber', pageNumber.toString())
+            .set('rowSet', rowSet.toString())
+            .set('country', country)
+            .set('progressiveLoading', progressiveLoading);
+        return this.http.get(`${this.apiUrl}/api/public/forms/${moduleName}`, {
+            headers,
+            params,
+        });
+    }
+    fetchDataFromDatabase(database, pageNumber = 0, pageSize = 10, searchString = '', enablePagination = false) {
+        const headers = new HttpHeaders({ 'Content-Type': 'application/json' });
+        const params = new HttpParams()
+            .set('page', pageNumber.toString())
+            .set('size', pageSize.toString())
+            .set('enablePagination', enablePagination.toString())
+            .set('searchKey', searchString);
+        return this.http.post(`${this.apiUrl}/api/load-from-db`, database, {
+            headers, params
+        });
+    }
+    fetchDataFromLookup(tableName) {
+        return this.http.get(`${this.apiUrl}/api/public/lookup/${tableName}`);
+    }
+    fetchDataFromExternalAPI(apiConfig, selectedValues = []) {
+        // ✅ Check if pagination exists
+        const hasPagination = apiConfig.params?.some((p) => p.valueSource === 'PAGE_INDEX') &&
+            apiConfig.params?.some((p) => p.valueSource === 'PAGE_SIZE');
+        // ---------------------- HEADERS ----------------------
+        let headers = new HttpHeaders();
+        // helper: resolve a value (or values) based on valueSource
+        // Apply to headers (assuming `headers` is an HttpHeaders instance)
+        if (apiConfig.headers) {
+            apiConfig.headers.forEach((header) => {
+                if (!header.keyName)
+                    return;
+                const rawValue = resolveValueFromSource(header.valueSource, header.inputValue, selectedValues);
+                if (header.valueSource === 'SELECTED_VALUES') {
+                    // Only add header if we have selected values
+                    if (Array.isArray(rawValue) && rawValue.length > 0) {
+                        if (header.inputValue === 'SINGLE_VALUE') {
+                            headers = headers.set(header.keyName, String(rawValue[0]));
+                        }
+                        else if (header.inputValue === 'ARRAY_OF_VALUES') {
+                            // join by comma for headers (common pattern)
+                            headers = headers.set(header.keyName, rawValue.join(','));
+                        }
+                        else {
+                            // fallback: join
+                            headers = headers.set(header.keyName, rawValue.join(','));
+                        }
+                    }
+                    // no selected values -> skip header
+                    return;
+                }
+                // For non-selected sources: skip when unresolved
+                if (rawValue === null || rawValue === undefined)
+                    return;
+                // If rawValue is array -> join by comma (headers expect single string)
+                const headerValue = Array.isArray(rawValue)
+                    ? rawValue.join(',')
+                    : String(rawValue);
+                if (header.keyName.toLowerCase() === 'authorization') {
+                    // add Bearer only when headerValue is truthy (and not already prefixed)
+                    const token = headerValue.startsWith('Bearer ')
+                        ? headerValue
+                        : `Bearer ${headerValue}`;
+                    headers = headers.set(header.keyName, token);
+                }
+                else {
+                    headers = headers.set(header.keyName, headerValue);
+                }
+            });
+        }
+        // ---------------------- PARAMS ----------------------
+        let params = new HttpParams();
+        // helper: resolve a value (or values) based on valueSource
+        function resolveValueFromSource(valueSource, inputValue, selectedValues = []) {
+            if (!valueSource)
+                return null;
+            switch (valueSource) {
+                case 'LOCAL_STORAGE':
+                    return localStorage.getItem(inputValue); // string or null
+                case 'SESSION_STORAGE':
+                    return sessionStorage.getItem(inputValue); // string or null
+                case 'CUSTOM_INPUT':
+                case 'QUESTION':
+                case 'PAGE_INDEX':
+                case 'PAGE_SIZE':
+                case 'SEARCH_STRING':
+                    // inputValue may be a single value or an array/CSV depending on usage
+                    return inputValue;
+                case 'SELECTED_VALUES':
+                    // For SELECTED_VALUES, return the selectedValues array (caller decides SINGLE/ARRAY behavior)
+                    return Array.isArray(selectedValues) ? selectedValues : [];
+                default:
+                    console.warn(`Unsupported valueSource for params: ${valueSource}`);
+                    return null;
+            }
+        }
+        // Usage: build params (assuming `params` is an HttpParams instance)
+        if (apiConfig.params) {
+            apiConfig.params.forEach((param) => {
+                if (!param.keyName)
+                    return;
+                // Resolve raw value based on source
+                const rawValue = resolveValueFromSource(param.valueSource, param.inputValue, selectedValues);
+                // If param expects selected values, handle SINGLE_VALUE vs ARRAY_OF_VALUES
+                if (param.valueSource === 'SELECTED_VALUES') {
+                    // Only add if there are actual selected values
+                    if (Array.isArray(rawValue) && rawValue.length > 0) {
+                        if (param.inputValue === 'SINGLE_VALUE') {
+                            // set to first selected value
+                            params = params.set(param.keyName, rawValue[0]);
+                        }
+                        else if (param.inputValue === 'ARRAY_OF_VALUES') {
+                            // append each selected value as repeated param
+                            rawValue.forEach((val) => {
+                                params = params.append(param.keyName, val);
+                            });
+                        }
+                        else {
+                            // if inputValue not provided, default to array behavior
+                            rawValue.forEach((val) => {
+                                params = params.append(param.keyName, val);
+                            });
+                        }
+                    }
+                    // if no selected values, skip adding this param
+                    return;
+                }
+                // For non-selected valueSources: rawValue could be null/undefined/string/array
+                if (rawValue === null || rawValue === undefined) {
+                    // skip adding param when value not found
+                    return;
+                }
+                // If inputValue indicates array-of-values (e.g., param.inputValue === 'ARRAY_OF_VALUES'),
+                // accept either an array or a comma-separated string
+                if (param.inputValue === 'ARRAY_OF_VALUES') {
+                    if (Array.isArray(rawValue)) {
+                        rawValue.forEach((val) => {
+                            params = params.append(param.keyName, val);
+                        });
+                    }
+                    else if (typeof rawValue === 'string') {
+                        // support comma separated string
+                        rawValue
+                            .split(',')
+                            .map((s) => s.trim())
+                            .filter(Boolean)
+                            .forEach((val) => {
+                            params = params.append(param.keyName, val);
+                        });
+                    }
+                    else {
+                        // fallback: convert to string and append
+                        params = params.append(param.keyName, String(rawValue));
+                    }
+                }
+                else {
+                    // default: set single value
+                    params = params.set(param.keyName, String(rawValue));
+                }
+            });
+        }
+        // ---------------------- PATH VARIABLES ----------------------
+        let url = apiConfig.url;
+        if (apiConfig.pathVariables) {
+            apiConfig.pathVariables.forEach((pathVar) => {
+                if (pathVar.keyName) {
+                    let valueToBind = null;
+                    switch (pathVar.valueSource) {
+                        case 'LOCAL_STORAGE':
+                            valueToBind = localStorage.getItem(pathVar.inputValue);
+                            break;
+                        case 'SESSION_STORAGE':
+                            valueToBind = sessionStorage.getItem(pathVar.inputValue);
+                            break;
+                        case 'CUSTOM_INPUT':
+                        case 'QUESTION':
+                            valueToBind = pathVar.inputValue;
+                            break;
+                        default:
+                            console.warn(`Unsupported valueSource: ${pathVar.valueSource}`);
+                    }
+                    if (valueToBind !== null && valueToBind !== undefined) {
+                        url = url.replace(`{${pathVar.keyName}}`, valueToBind);
+                    }
+                }
+            });
+        }
+        // ---------------------- FINAL CALL ----------------------
+        return this.http.get(url, { headers, params });
+    }
+    submitForm(moduleName, formData, reCAPTCHAToken) {
+        // const headers = new HttpHeaders({
+        //   'Auth-user': this.header.authUser,
+        // });
+        const headers = new HttpHeaders(this.getSafeHeaders());
+        const url = `${this.apiUrl}/api/public/forms/${moduleName}/submissions`;
+        if (reCAPTCHAToken) {
+            formData.append('recaptchaToken', reCAPTCHAToken);
+        }
+        return this.http.post(url, formData, {
+            headers,
+            observe: 'events',
+            reportProgress: true,
+        });
+    }
+    getSubmittedForm(moduleName, submissionId, pageNumber = 1, rowSet = 0, navigateTo) {
+        let params = new HttpParams()
+            .set('pageNumber', pageNumber.toString())
+            .set('rowSet', rowSet.toString());
+        if (navigateTo) {
+            params = params.set('navigateId', navigateTo);
+        }
+        if (this.parentQuestions) {
+            this.parentQuestions.forEach((q) => {
+                params = params.append('parentQuestions', q);
+            });
+        }
+        // const headers = new HttpHeaders({
+        //   'Accept-Language': this.header.acceptedLanguage,
+        // });
+        const headers = new HttpHeaders(this.getSafeHeaders());
+        return this.http.get(`${this.apiUrl}/api/forms/${moduleName}/submissions/${submissionId}`, { headers, params });
+    }
+    updateForm(moduleName, submissionId, formData, reCAPTCHAToken) {
+        // const headers = new HttpHeaders({
+        //   'Auth-user': this.header.authUser,
+        // });
+        const headers = new HttpHeaders(this.getSafeHeaders());
+        const url = `${this.apiUrl}/api/public/forms/${moduleName}/submissions/${submissionId}`;
+        if (reCAPTCHAToken) {
+            formData.append('recaptchaToken', reCAPTCHAToken);
+        }
+        return this.http.put(url, formData, {
+            headers,
+            observe: 'events',
+            reportProgress: true,
+        });
+    }
+    previewFile(url) {
+        // const headers = new HttpHeaders({
+        //   'Accept-Language': this.header.acceptedLanguage,
+        //   'Content-Type': this.header.contentType,
+        //   'auth-user': this.header.authUser,
+        //   'Authorization': `Bearer ${this.header.authorization}`,
+        // });
+        const headers = new HttpHeaders(this.getSafeHeaders());
+        const options = {
+            headers: headers,
+        };
+        const fileUrl = url;
+        const encodedFileUrl = encodeURIComponent(fileUrl);
+        const fullUrl = `?url=${encodedFileUrl}`;
+        return this.http.get(this.apiUrl + `/api/cdn/preview${fullUrl}`, options);
+    }
+    getSubformSubmissions(subFormData) {
+        if (!subFormData?.moduleName ||
+            !subFormData?.duplicateSubmission?.sourceSubmissionIds) {
+            return;
+        }
+        const headers = new HttpHeaders(this.getSafeHeaders());
+        // Extract data
+        const moduleName = subFormData.moduleName;
+        const submissionIds = subFormData.duplicateSubmission.sourceSubmissionIds;
+        // Build query string
+        const queryParams = submissionIds
+            .map((id) => `submissionIds=${encodeURIComponent(id)}`)
+            .join('&');
+        // Final URL
+        const url = `${this.apiUrl}/api/public/${moduleName}/subform-submissions?${queryParams}`;
+        // Now make API call
+        return this.http.get(url, {
+            headers
+        });
+    }
+    getSafeHeaders() {
+        const safe = {};
+        if (this.header && typeof this.header === 'object') {
+            for (const key of Object.keys(this.header)) {
+                const val = this.header[key];
+                if (val !== undefined && val !== null) {
+                    let headerKey = key;
+                    if (key === 'authUser') {
+                        headerKey = 'auth-user';
+                    }
+                    safe[headerKey] = String(val);
+                }
+            }
+        }
+        return safe;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormService, deps: [{ token: i1.HttpClient }, { token: i2.DataService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.DataService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form.service.js","sourceRoot":"","sources":["../../../../projects/form-submission/src/services/form.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';\r\nimport { DataService } from './data.service';\r\nimport { Observable } from 'rxjs';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class FormService {\r\n  private apiUrl: string = '';\r\n  header: any = {};\r\n  parentQuestions: any;\r\n  subformData: any;\r\n\r\n  constructor(private http: HttpClient, private dataService: DataService) {\r\n    this.dataService.apiUrl$.subscribe((data) => {\r\n      this.apiUrl = data;\r\n    });\r\n\r\n    this.dataService.header$.subscribe((data) => {\r\n      this.header = data;\r\n    });\r\n\r\n    this.dataService.parentQuestions$.subscribe((questions) => {\r\n      if (questions) {\r\n        this.parentQuestions = questions;\r\n      }\r\n    });\r\n\r\n    this.dataService.subform$.subscribe((data) => {\r\n      this.subformData = data;\r\n    });\r\n  }\r\n\r\n  getQuestions(\r\n    moduleName: string,\r\n    pageNumber: number = 1,\r\n    rowSet: number = 0,\r\n    progressiveLoading: boolean = true,\r\n    country: string = ''\r\n  ) {\r\n    const headers = new HttpHeaders(this.getSafeHeaders());\r\n    const params = new HttpParams()\r\n      .set('pageNumber', pageNumber.toString())\r\n      .set('rowSet', rowSet.toString())\r\n      .set('country', country)\r\n      .set('progressiveLoading', progressiveLoading);\r\n\r\n    return this.http.get<any>(`${this.apiUrl}/api/public/forms/${moduleName}`, {\r\n      headers,\r\n      params,\r\n    });\r\n  }\r\n\r\n  fetchDataFromDatabase(database: any, pageNumber:number=0, pageSize:number=10, searchString:string='',enablePagination:boolean=false): Observable<any> {\r\n    const headers = new HttpHeaders({ 'Content-Type': 'application/json' });\r\n    const params = new HttpParams()\r\n      .set('page', pageNumber.toString())\r\n      .set('size', pageSize.toString())\r\n      .set('enablePagination', enablePagination.toString())\r\n      .set('searchKey', searchString);\r\n    return this.http.post<any>(`${this.apiUrl}/api/load-from-db`, database, {\r\n      headers,params\r\n    });\r\n  }\r\n\r\n  fetchDataFromLookup(tableName: string) {\r\n    return this.http.get<any>(`${this.apiUrl}/api/public/lookup/${tableName}`);\r\n  }\r\n\r\n  fetchDataFromExternalAPI(\r\n    apiConfig: any,\r\n    selectedValues: any[] = []\r\n  ): Observable<any> {\r\n    // ✅ Check if pagination exists\r\n    const hasPagination =\r\n      apiConfig.params?.some((p: any) => p.valueSource === 'PAGE_INDEX') &&\r\n      apiConfig.params?.some((p: any) => p.valueSource === 'PAGE_SIZE');\r\n\r\n    // ---------------------- HEADERS ----------------------\r\n    let headers = new HttpHeaders();\r\n    // helper: resolve a value (or values) based on valueSource\r\n\r\n    // Apply to headers (assuming `headers` is an HttpHeaders instance)\r\n    if (apiConfig.headers) {\r\n      apiConfig.headers.forEach((header: any) => {\r\n        if (!header.keyName) return;\r\n\r\n        const rawValue = resolveValueFromSource(\r\n          header.valueSource,\r\n          header.inputValue,\r\n          selectedValues\r\n        );\r\n\r\n        if (header.valueSource === 'SELECTED_VALUES') {\r\n          // Only add header if we have selected values\r\n          if (Array.isArray(rawValue) && rawValue.length > 0) {\r\n            if (header.inputValue === 'SINGLE_VALUE') {\r\n              headers = headers.set(header.keyName, String(rawValue[0]));\r\n            } else if (header.inputValue === 'ARRAY_OF_VALUES') {\r\n              // join by comma for headers (common pattern)\r\n              headers = headers.set(header.keyName, rawValue.join(','));\r\n            } else {\r\n              // fallback: join\r\n              headers = headers.set(header.keyName, rawValue.join(','));\r\n            }\r\n          }\r\n          // no selected values -> skip header\r\n          return;\r\n        }\r\n\r\n        // For non-selected sources: skip when unresolved\r\n        if (rawValue === null || rawValue === undefined) return;\r\n\r\n        // If rawValue is array -> join by comma (headers expect single string)\r\n        const headerValue = Array.isArray(rawValue)\r\n          ? rawValue.join(',')\r\n          : String(rawValue);\r\n\r\n        if (header.keyName.toLowerCase() === 'authorization') {\r\n          // add Bearer only when headerValue is truthy (and not already prefixed)\r\n          const token = headerValue.startsWith('Bearer ')\r\n            ? headerValue\r\n            : `Bearer ${headerValue}`;\r\n          headers = headers.set(header.keyName, token);\r\n        } else {\r\n          headers = headers.set(header.keyName, headerValue);\r\n        }\r\n      });\r\n    }\r\n\r\n    // ---------------------- PARAMS ----------------------\r\n    let params = new HttpParams();\r\n    // helper: resolve a value (or values) based on valueSource\r\n    function resolveValueFromSource(\r\n      valueSource: string | undefined,\r\n      inputValue: any,\r\n      selectedValues: any[] = []\r\n    ) {\r\n      if (!valueSource) return null;\r\n\r\n      switch (valueSource) {\r\n        case 'LOCAL_STORAGE':\r\n          return localStorage.getItem(inputValue); // string or null\r\n\r\n        case 'SESSION_STORAGE':\r\n          return sessionStorage.getItem(inputValue); // string or null\r\n\r\n        case 'CUSTOM_INPUT':\r\n        case 'QUESTION':\r\n        case 'PAGE_INDEX':\r\n        case 'PAGE_SIZE':\r\n        case 'SEARCH_STRING':\r\n          // inputValue may be a single value or an array/CSV depending on usage\r\n          return inputValue;\r\n\r\n        case 'SELECTED_VALUES':\r\n          // For SELECTED_VALUES, return the selectedValues array (caller decides SINGLE/ARRAY behavior)\r\n          return Array.isArray(selectedValues) ? selectedValues : [];\r\n\r\n        default:\r\n          console.warn(`Unsupported valueSource for params: ${valueSource}`);\r\n          return null;\r\n      }\r\n    }\r\n\r\n    // Usage: build params (assuming `params` is an HttpParams instance)\r\n    if (apiConfig.params) {\r\n      apiConfig.params.forEach((param: any) => {\r\n        if (!param.keyName) return;\r\n\r\n        // Resolve raw value based on source\r\n        const rawValue = resolveValueFromSource(\r\n          param.valueSource,\r\n          param.inputValue,\r\n          selectedValues\r\n        );\r\n\r\n        // If param expects selected values, handle SINGLE_VALUE vs ARRAY_OF_VALUES\r\n        if (param.valueSource === 'SELECTED_VALUES') {\r\n          // Only add if there are actual selected values\r\n          if (Array.isArray(rawValue) && rawValue.length > 0) {\r\n            if (param.inputValue === 'SINGLE_VALUE') {\r\n              // set to first selected value\r\n              params = params.set(param.keyName, rawValue[0]);\r\n            } else if (param.inputValue === 'ARRAY_OF_VALUES') {\r\n              // append each selected value as repeated param\r\n              rawValue.forEach((val: any) => {\r\n                params = params.append(param.keyName, val);\r\n              });\r\n            } else {\r\n              // if inputValue not provided, default to array behavior\r\n              rawValue.forEach((val: any) => {\r\n                params = params.append(param.keyName, val);\r\n              });\r\n            }\r\n          }\r\n          // if no selected values, skip adding this param\r\n          return;\r\n        }\r\n\r\n        // For non-selected valueSources: rawValue could be null/undefined/string/array\r\n        if (rawValue === null || rawValue === undefined) {\r\n          // skip adding param when value not found\r\n          return;\r\n        }\r\n\r\n        // If inputValue indicates array-of-values (e.g., param.inputValue === 'ARRAY_OF_VALUES'),\r\n        // accept either an array or a comma-separated string\r\n        if (param.inputValue === 'ARRAY_OF_VALUES') {\r\n          if (Array.isArray(rawValue)) {\r\n            rawValue.forEach((val: any) => {\r\n              params = params.append(param.keyName, val);\r\n            });\r\n          } else if (typeof rawValue === 'string') {\r\n            // support comma separated string\r\n            rawValue\r\n              .split(',')\r\n              .map((s) => s.trim())\r\n              .filter(Boolean)\r\n              .forEach((val: string) => {\r\n                params = params.append(param.keyName, val);\r\n              });\r\n          } else {\r\n            // fallback: convert to string and append\r\n            params = params.append(param.keyName, String(rawValue));\r\n          }\r\n        } else {\r\n          // default: set single value\r\n          params = params.set(param.keyName, String(rawValue));\r\n        }\r\n      });\r\n    }\r\n\r\n    // ---------------------- PATH VARIABLES ----------------------\r\n    let url = apiConfig.url;\r\n    if (apiConfig.pathVariables) {\r\n      apiConfig.pathVariables.forEach((pathVar: any) => {\r\n        if (pathVar.keyName) {\r\n          let valueToBind: any = null;\r\n\r\n          switch (pathVar.valueSource) {\r\n            case 'LOCAL_STORAGE':\r\n              valueToBind = localStorage.getItem(pathVar.inputValue);\r\n              break;\r\n\r\n            case 'SESSION_STORAGE':\r\n              valueToBind = sessionStorage.getItem(pathVar.inputValue);\r\n              break;\r\n\r\n            case 'CUSTOM_INPUT':\r\n            case 'QUESTION':\r\n              valueToBind = pathVar.inputValue;\r\n              break;\r\n\r\n            default:\r\n              console.warn(`Unsupported valueSource: ${pathVar.valueSource}`);\r\n          }\r\n\r\n          if (valueToBind !== null && valueToBind !== undefined) {\r\n            url = url.replace(`{${pathVar.keyName}}`, valueToBind);\r\n          }\r\n        }\r\n      });\r\n    }\r\n\r\n    // ---------------------- FINAL CALL ----------------------\r\n    return this.http.get<any>(url, { headers, params });\r\n  }\r\n\r\n  submitForm(\r\n    moduleName: string,\r\n    formData: FormData,\r\n    reCAPTCHAToken?: string\r\n  ): Observable<any> {\r\n    // const headers = new HttpHeaders({\r\n    //   'Auth-user': this.header.authUser,\r\n    // });\r\n    const headers = new HttpHeaders(this.getSafeHeaders());\r\n    const url = `${this.apiUrl}/api/public/forms/${moduleName}/submissions`;\r\n    if (reCAPTCHAToken) {\r\n      formData.append('recaptchaToken', reCAPTCHAToken);\r\n    }\r\n    return this.http.post(url, formData, {\r\n      headers,\r\n      observe: 'events',\r\n      reportProgress: true,\r\n    });\r\n  }\r\n\r\n  getSubmittedForm(\r\n    moduleName: string,\r\n    submissionId: string,\r\n    pageNumber: number = 1,\r\n    rowSet: number = 0,\r\n    navigateTo?: string\r\n  ): Observable<any> {\r\n    let params = new HttpParams()\r\n      .set('pageNumber', pageNumber.toString())\r\n      .set('rowSet', rowSet.toString());\r\n    if (navigateTo) {\r\n      params = params.set('navigateId', navigateTo);\r\n    }\r\n\r\n    if (this.parentQuestions) {\r\n      this.parentQuestions.forEach((q: any) => {\r\n        params = params.append('parentQuestions', q);\r\n      });\r\n    }\r\n    // const headers = new HttpHeaders({\r\n    //   'Accept-Language': this.header.acceptedLanguage,\r\n    // });\r\n    const headers = new HttpHeaders(this.getSafeHeaders());\r\n    return this.http.get<any>(\r\n      `${this.apiUrl}/api/forms/${moduleName}/submissions/${submissionId}`,\r\n      { headers, params }\r\n    );\r\n  }\r\n\r\n  updateForm(\r\n    moduleName: string,\r\n    submissionId: string,\r\n    formData: FormData,\r\n    reCAPTCHAToken?: string\r\n  ): Observable<any> {\r\n    // const headers = new HttpHeaders({\r\n    //   'Auth-user': this.header.authUser,\r\n    // });\r\n    const headers = new HttpHeaders(this.getSafeHeaders());\r\n    const url = `${this.apiUrl}/api/public/forms/${moduleName}/submissions/${submissionId}`;\r\n    if (reCAPTCHAToken) {\r\n      formData.append('recaptchaToken', reCAPTCHAToken);\r\n    }\r\n    return this.http.put<any>(url, formData, {\r\n      headers,\r\n      observe: 'events',\r\n      reportProgress: true,\r\n    },);\r\n  }\r\n\r\n  previewFile(url: any): Observable<any> {\r\n    // const headers = new HttpHeaders({\r\n    //   'Accept-Language': this.header.acceptedLanguage,\r\n    //   'Content-Type': this.header.contentType,\r\n    //   'auth-user': this.header.authUser,\r\n    //   'Authorization': `Bearer ${this.header.authorization}`,\r\n    // });\r\n    const headers = new HttpHeaders(this.getSafeHeaders());\r\n    const options = {\r\n      headers: headers,\r\n    };\r\n    const fileUrl = url;\r\n    const encodedFileUrl = encodeURIComponent(fileUrl);\r\n    const fullUrl = `?url=${encodedFileUrl}`;\r\n    return this.http.get<any>(\r\n      this.apiUrl + `/api/cdn/preview${fullUrl}`,\r\n      options\r\n    );\r\n  }\r\n\r\n  getSubformSubmissions(subFormData: any) {\r\n    if (\r\n      !subFormData?.moduleName ||\r\n      !subFormData?.duplicateSubmission?.sourceSubmissionIds\r\n    ) {\r\n      return;\r\n    }\r\n\r\n    const headers = new HttpHeaders(this.getSafeHeaders());\r\n\r\n    // Extract data\r\n    const moduleName = subFormData.moduleName;\r\n    const submissionIds: string[] =\r\n      subFormData.duplicateSubmission.sourceSubmissionIds;\r\n\r\n    // Build query string\r\n    const queryParams = submissionIds\r\n      .map((id) => `submissionIds=${encodeURIComponent(id)}`)\r\n      .join('&');\r\n\r\n    // Final URL\r\n    const url = `${this.apiUrl}/api/public/${moduleName}/subform-submissions?${queryParams}`;\r\n\r\n    // Now make API call\r\n    return this.http.get(url, {\r\n      headers\r\n    });\r\n\r\n  }\r\n\r\n  getSafeHeaders(): { [key: string]: string } {\r\n    const safe: { [key: string]: string } = {};\r\n    if (this.header && typeof this.header === 'object') {\r\n      for (const key of Object.keys(this.header)) {\r\n        const val = this.header[key];\r\n        if (val !== undefined && val !== null) {\r\n          let headerKey = key;\r\n          if (key === 'authUser') {\r\n            headerKey = 'auth-user';\r\n          }\r\n          safe[headerKey] = String(val);\r\n        }\r\n      }\r\n    }\r\n    return safe;\r\n  }\r\n}\r\n"]}