@qbs-origin/origin-form 0.5.0

package/esm2022/lib/others/utils.mjs

@@ -0,0 +1,272 @@
+import { v4 as uuidv4 } from 'uuid';
+import { FormModelExtenxions, } from '../models/forms.model';
+import { Md5 } from 'ts-md5';
+export class Utils {
+    static { this.bigInt = Number(BigInt('900719925')); }
+    static json2csv(items) {
+        const replacer = (_key, value) => (value === null ? '' : value);
+        let header = Object.keys(items[0]);
+        header = header.filter((h) => h !== 'locked' && h != 'active');
+        const csv = [
+            header.join(','),
+            ...items.map((row) => header
+                .map((fieldName) => JSON.stringify(row[fieldName], replacer))
+                .join(',')),
+        ].join('\r\n');
+        return csv;
+    }
+    static csv2json(csv) {
+        const lines = csv.split(/\r?\n/).filter((line) => line.trim() !== '');
+        if (lines.length === 0)
+            return [];
+        const headers = Utils.parseCsvLine(lines[0]);
+        const result = [];
+        for (let i = 1; i < lines.length; i++) {
+            const obj = {};
+            const currentline = Utils.parseCsvLine(lines[i]);
+            for (let j = 0; j < headers.length; j++) {
+                const lineText = currentline[j];
+                if (lineText !== undefined) {
+                    obj[headers[j]] = Utils.trim(lineText, '"');
+                }
+            }
+            result.push(obj);
+        }
+        return result;
+    }
+    static parseCsvLine(line) {
+        const result = [];
+        let current = '';
+        let inQuotes = false;
+        for (let i = 0; i < line.length; i++) {
+            const char = line[i];
+            if (char === '"' && (i === 0 || line[i - 1] !== '\\')) {
+                inQuotes = !inQuotes;
+                continue;
+            }
+            if (char === ',' && !inQuotes) {
+                result.push(current);
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        result.push(current);
+        return result;
+    }
+    static trim(str, ch) {
+        var start = 0, end = str.length;
+        while (start < end && str[start] === ch)
+            ++start;
+        while (end > start && str[end - 1] === ch)
+            --end;
+        return start > 0 || end < str.length ? str.substring(start, end) : str;
+    }
+    static download(blob, name) {
+        const anchor = document.createElement('a');
+        anchor.download = name;
+        anchor.href = (window.webkitURL || window.URL).createObjectURL(blob);
+        anchor.click();
+    }
+    static generateUUID() {
+        return uuidv4();
+    }
+    static copyProperties(sourceObj, destObj) {
+        Object.keys(sourceObj).forEach((key) => (destObj[key] = sourceObj[key]));
+    }
+    static correctDate(date) {
+        return new Date(date.getTime() - date.getTimezoneOffset() * 60000);
+    }
+    static formatString(str, val) {
+        for (let index = 0; index < val.length; index++) {
+            str = str.replace(`{${index}}`, val[index]);
+        }
+        return str;
+    }
+    static removeNewLinesAndSpaces(str) {
+        return str.replace(/(\r\n|\n|\r)/gm, '').replace(/\s/g, '');
+    }
+    static removeNewLines(str) {
+        return str.replace(/(\r\n|\n|\r)/gm, '');
+    }
+    static findTranslation(translations, langIso) {
+        if (translations) {
+            var tr = translations.find((t) => t.languageIso == langIso);
+            if (tr && tr.value) {
+                return tr.value;
+            }
+        }
+        return '';
+    }
+    static findTranslationInfo(translationName, translations, langIso) {
+        if (translations) {
+            var tr = translations.find((t) => t.name == translationName);
+            if (tr) {
+                return this.findTranslation(tr.values, langIso);
+            }
+        }
+        ;
+        return '';
+    }
+    static findLanguageIsoById(languages, languageId) {
+        const match = languages.find((a) => a.id == languageId);
+        if (match) {
+            return match.iso;
+        }
+        return null;
+    }
+    static findLanguageIdByIso(languages, iso) {
+        const match = languages.find((a) => a.iso == iso);
+        if (match) {
+            return match.id;
+        }
+        return 0;
+    }
+    static findValueTranslation(translations, languageId) {
+        if (translations) {
+            var tr = translations.find((t) => t.languageId == languageId);
+            if (tr) {
+                return tr.value;
+            }
+        }
+        return undefined;
+    }
+    static findErrorTranslationValueOrDefault(errorsTranslations, langIso, errorCode) {
+        if (errorsTranslations) {
+            const found = errorsTranslations.find((e) => e.code === errorCode);
+            if (found) {
+                return found.translations.find((t) => t.languageIso === langIso)?.value ?? 'N/A';
+            }
+        }
+        return 'N/A';
+    }
+    static findErrorTranslationLabel(errorsTranslations, langIso, errorCode) {
+        if (errorsTranslations) {
+            const found = errorsTranslations.find((e) => e.code === errorCode);
+            if (found) {
+                return found.translations.find((t) => t.languageIso === langIso);
+            }
+        }
+        return undefined;
+    }
+    static createErrorTranslationMssageWithParameters(errorsTranslations, langIso, errorCode, params) {
+        const translation = Utils.findErrorTranslationLabel(errorsTranslations, langIso, errorCode);
+        let errorMessage = 'An error has occured';
+        if (translation && translation.value) {
+            errorMessage = translation.value;
+            if (params) {
+                for (let i = 0; i < params.length; i++) {
+                    errorMessage = errorMessage.replace('{' + i + '}', params[i]);
+                }
+            }
+        }
+        else
+            errorMessage = '';
+        return errorMessage;
+    }
+    static objectsAreEqual(obj1, obj2) {
+        if (obj1 && obj2) {
+            const string = JSON.stringify(this.removeUndefinedAndSortProperties(obj1));
+            const string2 = JSON.stringify(this.removeUndefinedAndSortProperties(obj2));
+            let hash = Md5.hashStr(string);
+            let hash2 = Md5.hashStr(string2);
+            return hash === hash2;
+        }
+        if (obj1 && !obj2) {
+            return false;
+        }
+        if (!obj1 && obj2) {
+            return false;
+        }
+        return true;
+    }
+    static removeUndefinedAndSortProperties(obj) {
+        if (typeof obj != 'object' || obj === null || obj === undefined) {
+            return obj;
+        }
+        if (obj instanceof Array) {
+            for (var i = 0; i < obj.length; i++) {
+                obj[i] = Utils.removeUndefinedAndSortProperties(obj[i]);
+            }
+            return obj;
+        }
+        var keys = Object.keys(obj);
+        keys.sort();
+        let newObject = {};
+        for (var i = 0; i < keys.length; i++) {
+            var val = obj[keys[i]];
+            if (val) {
+                newObject[keys[i]] = Utils.removeUndefinedAndSortProperties(val);
+            }
+        }
+        return newObject;
+    }
+    static getFileExtension(fileName) {
+        if (fileName) {
+            const splitted = fileName.split('.');
+            if (splitted.length > 1) {
+                return splitted.pop();
+            }
+        }
+        return undefined;
+    }
+    static getFieldsFromState(state, selectedMethodId, returnOwnFields) {
+        if (returnOwnFields) {
+            let apiMethod = [
+                ...(state.api?.getItems ?? []),
+                ...(state.api?.sendItems ?? []),
+            ].find((m) => m.id === selectedMethodId);
+            return apiMethod?.fields ?? [];
+        }
+        else {
+            if (!state) {
+                return [];
+            }
+            let ext = new FormModelExtenxions(state);
+            let fluxFields = ext.fluxItemsWithGetApiMethods(selectedMethodId);
+            return fluxFields;
+        }
+    }
+    static base64toBlob(b64Data, contentType = '', sliceSize = 512) {
+        const byteCharacters = atob(b64Data);
+        const byteArrays = [];
+        for (let offset = 0; offset < byteCharacters.length; offset += sliceSize) {
+            const slice = byteCharacters.slice(offset, offset + sliceSize);
+            const byteNumbers = new Array(slice.length);
+            for (let i = 0; i < slice.length; i++) {
+                byteNumbers[i] = slice.charCodeAt(i);
+            }
+            const byteArray = new Uint8Array(byteNumbers);
+            byteArrays.push(byteArray);
+        }
+        const blob = new Blob(byteArrays, { type: contentType });
+        return blob;
+    }
+    static copyToClipboard(text) {
+        if (navigator.clipboard && navigator.clipboard.writeText) {
+            return navigator.clipboard.writeText(text);
+        }
+        else {
+            // Fallback for unsupported browsers
+            return new Promise((resolve, reject) => {
+                const textarea = document.createElement('textarea');
+                textarea.value = text;
+                textarea.style.position = 'fixed';
+                document.body.appendChild(textarea);
+                textarea.focus();
+                textarea.select();
+                try {
+                    document.execCommand('copy');
+                    document.body.removeChild(textarea);
+                    resolve();
+                }
+                catch (err) {
+                    document.body.removeChild(textarea);
+                    reject(err);
+                }
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../projects/origin-form/src/lib/others/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { v4 as uuidv4 } from 'uuid';\nimport {\n  ErrorTranslations,\n  FormModel,\n  FormModelExtenxions,\n} from '../models/forms.model';\nimport { LabelInfo, TranslationInfo } from '../models/label-info.model';\nimport { Md5 } from 'ts-md5';\nimport { TranslationDto } from '../models/dictionary.model';\nimport { Language } from '../models/language.model';\n\nexport type CssRules = {\n  [key: string]: {\n    [property: string]: string;\n  };\n};\n\n\nexport class Utils {\n  static bigInt: number = Number(BigInt('900719925'));\n\n  static json2csv(items: any[]): string {\n    const replacer = (_key: any, value: null) => (value === null ? '' : value);\n    let header = Object.keys(items[0]);\n    header = header.filter((h) => h !== 'locked' && h != 'active');\n    const csv = [\n      header.join(','),\n      ...items.map((row: { [x: string]: any }) =>\n        header\n          .map((fieldName) => JSON.stringify(row[fieldName], replacer))\n          .join(',')\n      ),\n    ].join('\\r\\n');\n    return csv;\n  }\n\n  static csv2json(csv: string) {\n    const lines = csv.split(/\\r?\\n/).filter((line) => line.trim() !== '');\n    if (lines.length === 0) return [];\n\n    const headers = Utils.parseCsvLine(lines[0]);\n    const result = [];\n\n    for (let i = 1; i < lines.length; i++) {\n      const obj: any = {};\n      const currentline = Utils.parseCsvLine(lines[i]);\n      for (let j = 0; j < headers.length; j++) {\n        const lineText = currentline[j];\n        if (lineText !== undefined) {\n          obj[headers[j]] = Utils.trim(lineText, '\"');\n        }\n      }\n      result.push(obj);\n    }\n\n    return result;\n  }\n\n  static parseCsvLine(line: string): string[] {\n    const result: string[] = [];\n    let current = '';\n    let inQuotes = false;\n\n    for (let i = 0; i < line.length; i++) {\n      const char = line[i];\n      if (char === '\"' && (i === 0 || line[i - 1] !== '\\\\')) {\n        inQuotes = !inQuotes;\n        continue;\n      }\n      if (char === ',' && !inQuotes) {\n        result.push(current);\n        current = '';\n      } else {\n        current += char;\n      }\n    }\n    result.push(current);\n    return result;\n  }\n\n  static trim(str: string, ch: string) {\n    var start = 0,\n      end = str.length;\n    while (start < end && str[start] === ch) ++start;\n    while (end > start && str[end - 1] === ch) --end;\n    return start > 0 || end < str.length ? str.substring(start, end) : str;\n  }\n\n  static download(blob: Blob, name: string): void {\n    const anchor = document.createElement('a');\n    anchor.download = name;\n    anchor.href = (window.webkitURL || window.URL).createObjectURL(blob);\n    anchor.click();\n  }\n\n  static generateUUID(): string {\n    return uuidv4();\n  }\n\n  static copyProperties(sourceObj: any, destObj: any) {\n    Object.keys(sourceObj).forEach((key) => (destObj[key] = sourceObj[key]));\n  }\n\n  static correctDate(date: Date) {\n    return new Date(date.getTime() - date.getTimezoneOffset() * 60000);\n  }\n\n  static formatString(str: string, val: string[]) {\n    for (let index = 0; index < val.length; index++) {\n      str = str.replace(`{${index}}`, val[index]);\n    }\n    return str;\n  }\n\n  static removeNewLinesAndSpaces(str: string) {\n    return str.replace(/(\\r\\n|\\n|\\r)/gm, '').replace(/\\s/g, '');\n  }\n\n  static removeNewLines(str: string) {\n    return str.replace(/(\\r\\n|\\n|\\r)/gm, '');\n  }\n\n  static findTranslation(\n    translations: LabelInfo[],\n    langIso: string\n  ): string | undefined {\n    if (translations) {\n      var tr = translations.find((t) => t.languageIso == langIso);\n      if (tr && tr.value) {\n        return tr.value;\n      }\n    }\n    return '';\n  }\n\n  static findTranslationInfo(\n    translationName: string,\n    translations: TranslationInfo[],\n    langIso: string\n  ): string | undefined {    \n    if (translations) {\n      var tr = translations.find((t) => t.name == translationName);\n      if (tr) {\n        return this.findTranslation(tr.values, langIso);\n      }\n    };\n    return '';\n  }\n\n  static findLanguageIsoById(\n    languages: Language[],\n    languageId: number\n  ): string {\n    const match = languages.find((a) => a.id == languageId);\n    if (match) {\n      return match.iso;\n    }\n    return null as any;\n  }\n\n  static findLanguageIdByIso(languages: Language[], iso: string): number {\n    const match = languages.find((a) => a.iso == iso);\n    if (match) {\n      return match.id;\n    }\n    return 0;\n  }\n\n  static findValueTranslation(\n    translations: TranslationDto[],\n    languageId: number\n  ): string | undefined {\n    if (translations) {\n      var tr = translations.find((t) => t.languageId == languageId);\n      if (tr) {\n        return tr.value;\n      }\n    }\n    return undefined;\n  }\n\n  static findErrorTranslationValueOrDefault(\n    errorsTranslations: ErrorTranslations[],\n    langIso: string,\n    errorCode: string\n  ): string {\n    if (errorsTranslations) {\n      const found = errorsTranslations.find((e) => e.code === errorCode);\n      if (found) {\n        return found.translations.find((t) => t.languageIso === langIso)?.value ?? 'N/A';\n      }\n    }\n    return 'N/A';\n  }\n\n  static findErrorTranslationLabel(\n    errorsTranslations: ErrorTranslations[],\n    langIso: string,\n    errorCode: string\n  ): LabelInfo | undefined {\n    if (errorsTranslations) {\n      const found = errorsTranslations.find((e) => e.code === errorCode);\n      if (found) {\n        return found.translations.find((t) => t.languageIso === langIso);\n      }\n    }\n    return undefined;\n  }\n\n  static createErrorTranslationMssageWithParameters(\n    errorsTranslations: ErrorTranslations[],\n    langIso: string,\n    errorCode: string,\n    params: string[]\n  ) {\n    const translation = Utils.findErrorTranslationLabel(\n      errorsTranslations,\n      langIso,\n      errorCode\n    );\n    let errorMessage = 'An error has occured';\n    if (translation && translation.value) {\n      errorMessage = translation.value;\n      if (params) {\n        for (let i = 0; i < params.length; i++) {\n          errorMessage = errorMessage.replace('{' + i + '}', params[i]);\n        }\n      }\n    } else errorMessage = '';\n\n    return errorMessage;\n  }\n\n  static objectsAreEqual(obj1: any, obj2: any) {\n    if (obj1 && obj2) {\n      const string = JSON.stringify(\n        this.removeUndefinedAndSortProperties(obj1)\n      );\n      const string2 = JSON.stringify(\n        this.removeUndefinedAndSortProperties(obj2)\n      );\n      let hash = Md5.hashStr(string);\n      let hash2 = Md5.hashStr(string2);\n      return hash === hash2;\n    }\n    if (obj1 && !obj2) {\n      return false;\n    }\n    if (!obj1 && obj2) {\n      return false;\n    }\n    return true;\n  }\n\n  static removeUndefinedAndSortProperties(obj: any) {\n    if (typeof obj != 'object' || obj === null || obj === undefined) {\n      return obj;\n    }\n    if (obj instanceof Array) {\n      for (var i = 0; i < obj.length; i++) {\n        obj[i] = Utils.removeUndefinedAndSortProperties(obj[i]);\n      }\n      return obj;\n    }\n\n    var keys = Object.keys(obj);\n    keys.sort();\n    let newObject: any = {};\n    for (var i = 0; i < keys.length; i++) {\n      var val = obj[keys[i]];\n      if (val) {\n        newObject[keys[i]] = Utils.removeUndefinedAndSortProperties(val);\n      }\n    }\n    return newObject;\n  }\n\n  static getFileExtension(fileName: string): string | undefined {\n    if (fileName) {\n      const splitted = fileName.split('.');\n      if (splitted.length > 1) {\n        return splitted.pop();\n      }\n    }\n    return undefined;\n  }\n\n  static getFieldsFromState(\n    state: FormModel,\n    selectedMethodId: string,\n    returnOwnFields?: boolean\n  ) {\n    if (returnOwnFields) {\n      let apiMethod = [\n        ...(state.api?.getItems ?? []),\n        ...(state.api?.sendItems ?? []),\n      ].find((m) => m.id === selectedMethodId);\n      return apiMethod?.fields ?? [];\n    } else {\n      if (!state) {\n        return [];\n      }\n      let ext = new FormModelExtenxions(state);\n      let fluxFields = ext.fluxItemsWithGetApiMethods(selectedMethodId);\n\n      return fluxFields;\n    }\n  }\n\n  static base64toBlob(b64Data: string, contentType = '', sliceSize = 512) {\n    const byteCharacters = atob(b64Data);\n    const byteArrays = [];\n\n    for (let offset = 0; offset < byteCharacters.length; offset += sliceSize) {\n      const slice = byteCharacters.slice(offset, offset + sliceSize);\n\n      const byteNumbers = new Array(slice.length);\n      for (let i = 0; i < slice.length; i++) {\n        byteNumbers[i] = slice.charCodeAt(i);\n      }\n\n      const byteArray = new Uint8Array(byteNumbers);\n      byteArrays.push(byteArray);\n    }\n\n    const blob = new Blob(byteArrays, { type: contentType });\n    return blob;\n  }\n\n  static copyToClipboard(text: string): Promise<void> {\n    if (navigator.clipboard && navigator.clipboard.writeText) {\n      return navigator.clipboard.writeText(text);\n    } else {\n      // Fallback for unsupported browsers\n      return new Promise((resolve, reject) => {\n        const textarea = document.createElement('textarea');\n        textarea.value = text;\n        textarea.style.position = 'fixed';\n        document.body.appendChild(textarea);\n        textarea.focus();\n        textarea.select();\n        try {\n          document.execCommand('copy');\n          document.body.removeChild(textarea);\n          resolve();\n        } catch (err) {\n          document.body.removeChild(textarea);\n          reject(err);\n        }\n      });\n    }\n  }\n}\n"]}

package/esm2022/lib/services/applicationData.service.mjs

@@ -0,0 +1,145 @@
+import { Injectable, inject } from '@angular/core';
+import { catchError, firstValueFrom, map, of } from 'rxjs';
+import { ConfigService } from '../others/config-service';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth-http.service";
+export class ApplicationDataService {
+    constructor(http) {
+        this.http = http;
+        this.configService = inject(ConfigService);
+    }
+    uploadDocuments(uploadDocumentsDto) {
+        const createUrl = this.configService.readConfig().baseUrlBusiness +
+            '/appdata/uploadDocuments';
+        return this.http.post(createUrl, uploadDocumentsDto);
+    }
+    generateDocuments(generateDocumentsCommand) {
+        const url = this.configService.readConfig().baseUrlBusiness +
+            '/appdata/GenerateDocuments';
+        return this.http.post(url, generateDocumentsCommand);
+    }
+    getGenerateDocuments(getCommand) {
+        const url = this.configService.readConfig().baseUrlBusiness +
+            '/appdata/GetGeneratedDocuments';
+        return this.http.post(url, getCommand);
+    }
+    downloadFile(appDataId, docId, fileName) {
+        const url = this.configService.readConfig().baseUrlBusiness +
+            `/FileServer/download?appDataId=${appDataId}&docId=${docId}&fileName=${fileName}`;
+        return this.http.getExtended(url, { responseType: 'blob' });
+    }
+    scanId(scanIdCommand) {
+        const url = this.configService.readConfig().baseUrlBusiness + '/appdata/ScanId';
+        return this.http.post(url, scanIdCommand);
+    }
+    async getSteps(appDataId) {
+        const getUrl = this.configService.readConfig().baseUrlBusiness +
+            `/appdata/GetById/${appDataId}`;
+        var promise = this.http.get(getUrl).pipe(map((appData) => appData));
+        return await firstValueFrom(promise);
+    }
+    saveApp(appData) {
+        const saveUrl = this.configService.readConfig().baseUrlBusiness + '/appdata/SaveAppData';
+        const payload = {
+            ...appData,
+            fillData: appData.fillData ? JSON.stringify(appData.fillData) : undefined,
+        };
+        return this.http.post(saveUrl, payload);
+    }
+    saveStep(appDataId, currentStep, selectedOfferId = undefined) {
+        const saveUrl = this.configService.readConfig().baseUrlBusiness +
+            '/appdata/SaveAppDataStep';
+        const payload = {
+            appDataId: appDataId,
+            stepData: JSON.stringify(currentStep),
+            withNextStep: true,
+            selectedOfferId: selectedOfferId,
+        };
+        return this.http.post(saveUrl, payload);
+    }
+    getPreviousStep(appDataId) {
+        const getUrl = this.configService.readConfig().baseUrlBusiness +
+            '/appdata/setPreviousStep?appId=' +
+            appDataId;
+        return this.http.get(getUrl);
+    }
+    validateApi(apiValidateRequest) {
+        const url = this.configService.readConfig().baseUrlBusiness + '/ApiRequest/dorequest';
+        return this.http.post(url, apiValidateRequest);
+    }
+    doDocumentRequest(apiValidateRequest) {
+        const url = this.configService.readConfig().baseUrlBusiness +
+            '/ApiRequest/doDocumentRequest';
+        return this.http.post(url, apiValidateRequest);
+    }
+    convertDocumentToPdf(request) {
+        const url = this.configService.readConfig().baseUrlBusiness + '/appdata/convertToPdf';
+        return this.http.post(url, request);
+    }
+    makeActionApiCall(actionRequest) {
+        console.log('actionRequest from makeActionApiCall', actionRequest);
+        const url = this.configService.readConfig().baseUrlBusiness + '/MakeAction/doaction';
+        return this.http.post(url, actionRequest);
+    }
+    makeProcessApiCall(appDataID) {
+        const url = this.configService.readConfig().baseUrlInfrastructure + '/Process';
+        return this.http.post(url, { appId: appDataID }).pipe(map((response) => {
+            console.log('response from makeProcessApiCall', response), response;
+        }), catchError((error) => of({ ...error, body: false })));
+    }
+    getProcessStatus(appDataID) {
+        const url = this.configService.readConfig().baseUrlInfrastructure +
+            '/Process/get-status?appId=' +
+            appDataID;
+        return this.http.get(url);
+    }
+    getOffers(appDataId) {
+        const url = this.configService.readConfig().baseUrlBusiness +
+            `/appdata/getOffers/${appDataId}`;
+        return this.http.get(url);
+    }
+    makeStatusApiCall(appDataId, stepId, setNextStep = false) {
+        const url = this.configService.readConfig().baseUrlBusiness +
+            '/appdata/doStatusAction';
+        return this.http.post(url, {
+            appDataId: appDataId,
+            stepId: stepId,
+            setNextStep: setNextStep,
+        });
+    }
+    async setCurrentStep(appDataId, stepId) {
+        const url = this.configService.readConfig().baseUrlBusiness +
+            `/appdata/setCurrentStep?appId=${appDataId}&stepId=${stepId}`;
+        const response = await firstValueFrom(this.http.getExtended(url, { responseType: 'text' }));
+        return response;
+    }
+    enrolCard(enrolCardCommand) {
+        const url = this.configService.readConfig().baseUrlBusiness + '/appdata/EnrolCard';
+        return this.http.post(url, enrolCardCommand);
+    }
+    getEnrolmentStatus(dataUrlId) {
+        const url = this.configService.readConfig().baseUrlBusiness +
+            `/appdata/GetEnrolmentStatus/${dataUrlId}`;
+        return this.http.get(url);
+    }
+    getDataUrl(dataUrlId) {
+        const url = this.configService.readConfig().baseUrlBusiness +
+            `/DataURL/GetById/${dataUrlId}`;
+        return this.http.get(url);
+    }
+    changeLanguage(appDataUuid, languageISOCode) {
+        const url = this.configService.readConfig().baseUrlBusiness +
+            '/appdata/changeLanguage';
+        const payload = {
+            appDataId: appDataUuid,
+            languageIso: languageISOCode,
+        };
+        return this.http.post(url, payload);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApplicationDataService, deps: [{ token: i1.AuthHttpService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApplicationDataService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApplicationDataService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.AuthHttpService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"applicationData.service.js","sourceRoot":"","sources":["../../../../../projects/origin-form/src/lib/services/applicationData.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { catchError, firstValueFrom, map, Observable, of } from 'rxjs';\nimport { ConfigService } from '../others/config-service';\nimport {\n    ApiDocumentRequest,\n  ApiValidateRequest,\n  ApplicationEnrolCardDto,\n  ApplicationGenerateDocumentsDto,\n  ApplicationGetGeneratedDocumentsDto,\n  ApplicationUploadDocumentsDto,\n  ConvertDocumentToPdfRequest,\n  ConvertDocumentToPdfResponse,\n  GeneratedDocument,\n  MakeActionRequest,\n  ScanIdDto,\n} from '../models/application.model';\nimport { AppData } from '../models/forms.model';\nimport { AuthHttpService } from './auth-http.service';\n\n@Injectable()\nexport class ApplicationDataService {\n  constructor(private http: AuthHttpService) {}\n\n  configService = inject(ConfigService);\n\n  uploadDocuments(\n    uploadDocumentsDto: ApplicationUploadDocumentsDto\n  ): Observable<string[]> {\n    const createUrl =\n      this.configService.readConfig().baseUrlBusiness +\n      '/appdata/uploadDocuments';\n    return this.http.post<any>(createUrl, uploadDocumentsDto);\n  }\n\n  generateDocuments(\n    generateDocumentsCommand: ApplicationGenerateDocumentsDto\n  ): Observable<any> {\n    const url =\n      this.configService.readConfig().baseUrlBusiness +\n      '/appdata/GenerateDocuments';\n    return this.http.post<string[]>(url, generateDocumentsCommand);\n  }\n\n  getGenerateDocuments(\n    getCommand: ApplicationGetGeneratedDocumentsDto\n  ): Observable<GeneratedDocument[]> {\n    const url =\n      this.configService.readConfig().baseUrlBusiness +\n      '/appdata/GetGeneratedDocuments';\n    return this.http.post<GeneratedDocument[]>(url, getCommand);\n  }\n\n  downloadFile(\n    appDataId: string,\n    docId: string,\n    fileName: string\n  ): Observable<any> {\n    const url =\n      this.configService.readConfig().baseUrlBusiness +\n      `/FileServer/download?appDataId=${appDataId}&docId=${docId}&fileName=${fileName}`;\n    return this.http.getExtended(url, { responseType: 'blob' });\n  }\n\n  scanId(scanIdCommand: ScanIdDto): Observable<number> {\n    const url =\n      this.configService.readConfig().baseUrlBusiness + '/appdata/ScanId';\n    return this.http.post<number>(url, scanIdCommand);\n  }\n\n  async getSteps(appDataId: string): Promise<any> {\n    const getUrl =\n      this.configService.readConfig().baseUrlBusiness +\n      `/appdata/GetById/${appDataId}`;\n\n    var promise = this.http.get<any>(getUrl).pipe(map((appData) => appData));\n    return await firstValueFrom(promise);\n  }\n\n  saveApp(appData: AppData): Observable<any> {\n    const saveUrl =\n      this.configService.readConfig().baseUrlBusiness + '/appdata/SaveAppData';\n\n    const payload = {\n      ...appData,\n      fillData: appData.fillData ? JSON.stringify(appData.fillData) : undefined,\n    };\n\n    return this.http.post<any>(saveUrl, payload);\n  }\n\n  saveStep(\n    appDataId: string,\n    currentStep: any,\n    selectedOfferId: any = undefined\n  ): Observable<any> {\n    const saveUrl =\n      this.configService.readConfig().baseUrlBusiness +\n      '/appdata/SaveAppDataStep';\n\n    const payload = {\n      appDataId: appDataId,\n      stepData: JSON.stringify(currentStep),\n      withNextStep: true,\n      selectedOfferId: selectedOfferId,\n    };\n\n    return this.http.post<any>(saveUrl, payload);\n  }\n\n  getPreviousStep(appDataId: string): Observable<any> {\n    const getUrl =\n      this.configService.readConfig().baseUrlBusiness +\n      '/appdata/setPreviousStep?appId=' +\n      appDataId;\n\n    return this.http.get<any>(getUrl);\n  }\n\n  validateApi(apiValidateRequest: ApiValidateRequest): Observable<any> {\n    const url =\n      this.configService.readConfig().baseUrlBusiness + '/ApiRequest/dorequest';\n    return this.http.post<any>(url, apiValidateRequest);\n  }\n\n  doDocumentRequest(apiValidateRequest: ApiDocumentRequest): Observable<any[]> {\n    const url =\n      this.configService.readConfig().baseUrlBusiness +\n      '/ApiRequest/doDocumentRequest';\n    return this.http.post<any>(url, apiValidateRequest);\n  }\n\n  convertDocumentToPdf(\n    request: ConvertDocumentToPdfRequest\n  ): Observable<ConvertDocumentToPdfResponse> {\n    const url =\n      this.configService.readConfig().baseUrlBusiness + '/appdata/convertToPdf';\n    return this.http.post<ConvertDocumentToPdfResponse>(url, request);\n  }\n\n  makeActionApiCall(actionRequest: MakeActionRequest): Observable<any> {\n    console.log('actionRequest from makeActionApiCall', actionRequest);\n    const url =\n      this.configService.readConfig().baseUrlBusiness + '/MakeAction/doaction';\n    return this.http.post<any>(url, actionRequest);\n  }\n\n  makeProcessApiCall(appDataID: string): Observable<any> {\n    const url =\n      this.configService.readConfig().baseUrlInfrastructure + '/Process';\n    return this.http.post<any>(url, { appId: appDataID }).pipe(\n      map((response) => {\n        console.log('response from makeProcessApiCall', response), response;\n      }),\n\n      catchError((error) => of({ ...error, body: false }))\n    );\n  }\n\n  getProcessStatus(appDataID: string): Observable<number> {\n    const url =\n      this.configService.readConfig().baseUrlInfrastructure +\n      '/Process/get-status?appId=' +\n      appDataID;\n    return this.http.get<number>(url);\n  }\n\n  getOffers(appDataId: string): Observable<any> {\n    const url =\n      this.configService.readConfig().baseUrlBusiness +\n      `/appdata/getOffers/${appDataId}`;\n    return this.http.get<any>(url);\n  }\n\n  makeStatusApiCall(\n    appDataId: string,\n    stepId: string,\n    setNextStep: boolean = false\n  ) {\n    const url =\n      this.configService.readConfig().baseUrlBusiness +\n      '/appdata/doStatusAction';\n    return this.http.post<any>(url, {\n      appDataId: appDataId,\n      stepId: stepId,\n      setNextStep: setNextStep,\n    });\n  }\n\n  async setCurrentStep(appDataId: string, stepId: string) {\n    const url =\n      this.configService.readConfig().baseUrlBusiness +\n      `/appdata/setCurrentStep?appId=${appDataId}&stepId=${stepId}`;\n    const response = await firstValueFrom(\n      this.http.getExtended(url, { responseType: 'text' })\n    );\n    return response;\n  }\n\n  enrolCard(enrolCardCommand: ApplicationEnrolCardDto): Observable<any> {\n    const url =\n      this.configService.readConfig().baseUrlBusiness + '/appdata/EnrolCard';\n    return this.http.post<string[]>(url, enrolCardCommand);\n  }\n\n  getEnrolmentStatus(dataUrlId: string): Observable<any> {\n    const url =\n      this.configService.readConfig().baseUrlBusiness +\n      `/appdata/GetEnrolmentStatus/${dataUrlId}`;\n    return this.http.get<any>(url);\n  }\n\n  getDataUrl(dataUrlId: string): Observable<any> {\n    const url =\n      this.configService.readConfig().baseUrlBusiness +\n      `/DataURL/GetById/${dataUrlId}`;\n    return this.http.get<any>(url);\n  }\n\n    changeLanguage(appDataUuid: string, languageISOCode: string) {\n    const url =\n      this.configService.readConfig().baseUrlBusiness +\n      '/appdata/changeLanguage';\n\n    const payload = {\n      appDataId: appDataUuid,\n      languageIso: languageISOCode,\n    };\n\n    return this.http.post<any>(url, payload);\n  }\n}\n"]}

package/esm2022/lib/services/auth-http.service.mjs

@@ -0,0 +1,80 @@
+import { Injectable } from '@angular/core';
+import { HttpHeaders, } from '@angular/common/http';
+import { catchError, switchMap, throwError } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../origin-form-auth.service";
+export class AuthHttpService {
+    constructor(http, authService) {
+        this.http = http;
+        this.authService = authService;
+        this.isRefreshing = false;
+    }
+    getHeaders() {
+        const token = this.authService.getToken();
+        return new HttpHeaders({
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        });
+    }
+    get(url) {
+        return this.http
+            .get(url, { headers: this.getHeaders() })
+            .pipe(catchError((error) => this.handleError(error, () => this.get(url))));
+    }
+    getExtended(url, options = {}) {
+        return this.http
+            .get(url, { ...options, headers: this.getHeaders() })
+            .pipe(catchError((error) => this.handleError(error, () => this.getExtended(url, options))));
+    }
+    post(url, body) {
+        return this.http
+            .post(url, body, { headers: this.getHeaders() })
+            .pipe(catchError((error) => this.handleError(error, () => this.post(url, body))));
+    }
+    postExtended(url, body, options = null) {
+        return this.http
+            .post(url, body, { ...options, headers: this.getHeaders() })
+            .pipe(catchError((error) => this.handleError(error, () => this.postExtended(url, body, options))));
+    }
+    put(url, body) {
+        return this.http
+            .put(url, body, { headers: this.getHeaders() })
+            .pipe(catchError((error) => this.handleError(error, () => this.put(url, body))));
+    }
+    delete(url) {
+        return this.http
+            .delete(url, { headers: this.getHeaders() })
+            .pipe(catchError((error) => this.handleError(error, () => this.delete(url))));
+    }
+    handleError(error, retryRequest) {
+        if (error.status === 401) {
+            return this.handle401Error(retryRequest);
+        }
+        return throwError(() => error);
+    }
+    handle401Error(retryRequest) {
+        if (!this.isRefreshing) {
+            this.isRefreshing = true;
+            return this.authService.refreshToken().pipe(switchMap((newToken) => {
+                this.isRefreshing = false;
+                return retryRequest(); // Retry the failed request with the new token
+            }), catchError((err) => {
+                this.isRefreshing = false;
+                return throwError(() => err);
+            }));
+        }
+        else {
+            return retryRequest();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthHttpService, deps: [{ token: i1.HttpClient }, { token: i2.OriginFormAuthService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthHttpService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthHttpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root', // Ensures it is available in the application using the library
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.OriginFormAuthService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-http.service.js","sourceRoot":"","sources":["../../../../../projects/origin-form/src/lib/services/auth-http.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  HttpClient,\n  HttpErrorResponse,\n  HttpEvent,\n  HttpHeaders,\n  HttpResponse,\n} from '@angular/common/http';\nimport { catchError, Observable, switchMap, throwError } from 'rxjs';\nimport { OriginFormAuthService } from '../origin-form-auth.service';\n\n@Injectable({\n  providedIn: 'root', // Ensures it is available in the application using the library\n})\nexport class AuthHttpService {\n  private isRefreshing = false;\n\n  constructor(\n    private http: HttpClient,\n    private authService: OriginFormAuthService\n  ) {}\n\n  private getHeaders(): HttpHeaders {\n    const token = this.authService.getToken();\n    return new HttpHeaders({\n      Authorization: `Bearer ${token}`,\n      'Content-Type': 'application/json',\n    });\n  }\n\n  get<T>(url: string): Observable<T> {\n    return this.http\n      .get<T>(url, { headers: this.getHeaders() })\n      .pipe(\n        catchError((error) => this.handleError(error, () => this.get<T>(url)))\n      );\n  }\n\n  getExtended<T>(url: string, options: any = {}): Observable<T | HttpEvent<T>> {\n    return this.http\n      .get<T>(url, { ...options, headers: this.getHeaders() })\n      .pipe(\n        catchError((error) =>\n          this.handleError(error, () => this.getExtended<T>(url, options))\n        )\n      );\n  }\n\n  post<T>(url: string, body: any): Observable<T> {\n    return this.http\n      .post<T>(url, body, { headers: this.getHeaders() })\n      .pipe(\n        catchError((error) =>\n          this.handleError(error, () => this.post<T>(url, body))\n        )\n      );\n  }\n\n  postExtended<T>(\n    url: string,\n    body: any,\n    options: any | null = null\n  ): Observable<T | HttpEvent<T>> {\n    return this.http\n      .post<T>(url, body, { ...options, headers: this.getHeaders() })\n      .pipe(\n        catchError((error) =>\n          this.handleError(error, () =>\n            this.postExtended<T>(url, body, options)\n          )\n        )\n      );\n  }\n\n  put<T>(url: string, body: any): Observable<T> {\n    return this.http\n      .put<T>(url, body, { headers: this.getHeaders() })\n      .pipe(\n        catchError((error) =>\n          this.handleError(error, () => this.put<T>(url, body))\n        )\n      );\n  }\n\n  delete<T>(url: string): Observable<T> {\n    return this.http\n      .delete<T>(url, { headers: this.getHeaders() })\n      .pipe(\n        catchError((error) =>\n          this.handleError(error, () => this.delete<T>(url))\n        )\n      );\n  }\n\n  private handleError<T>(\n    error: HttpErrorResponse,\n    retryRequest: () => Observable<T>\n  ): Observable<T> {\n    if (error.status === 401) {\n      return this.handle401Error(retryRequest);\n    }\n    return throwError(() => error);\n  }\n\n  private handle401Error<T>(retryRequest: () => Observable<T>): Observable<T> {\n    if (!this.isRefreshing) {\n      this.isRefreshing = true;\n\n      return this.authService.refreshToken().pipe(\n        switchMap((newToken) => {\n          this.isRefreshing = false;\n          return retryRequest(); // Retry the failed request with the new token\n        }),\n        catchError((err) => {\n          this.isRefreshing = false;\n          return throwError(() => err);\n        })\n      );\n    } else {\n      return retryRequest();\n    }\n  }\n}\n"]}