@qbs-origin/origin-form 0.5.0

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

@@ -0,0 +1,56 @@
+import { Injectable } from '@angular/core';
+import { Utils } from '../others/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/snack-bar";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "../others/translation.pipe";
+export class DialogService {
+    constructor(snackBar, dialog, translate) {
+        this.snackBar = snackBar;
+        this.dialog = dialog;
+        this.translate = translate;
+    }
+    popError(message, ...params) {
+        this.popErrorsCore([message], params);
+    }
+    popErrors(labels, duration = 2000) {
+        this.popErrorsCore(labels, undefined, duration);
+    }
+    popErrorTranslation(errorsTranslations, langIso, errorCode, ...params) {
+        const errorMessage = Utils.createErrorTranslationMssageWithParameters(errorsTranslations, langIso, errorCode, params);
+        this.popError(errorMessage);
+    }
+    popErrorsCore(labels, params, duration = 2000, panelClass = ['error-snack-bar']) {
+        let message = labels
+            .map((i) => this.translate.transform(i))
+            .join('\r\n');
+        if (params) {
+            for (let i = 0; i < params.length; i++) {
+                message = message.replace('{' + i + '}', params[i]);
+            }
+        }
+        if (message.length > 1000) {
+            message = message.substring(0, 1000);
+        }
+        this.snackBar.open(message, '', {
+            duration,
+            panelClass,
+        });
+    }
+    popSuccess(message, duration = 2000, panelClass = ['success-snack-bar']) {
+        this.snackBar.open(message, '', {
+            duration,
+            panelClass,
+        });
+    }
+    openDialog(component, config) {
+        return this.dialog.open(component, config);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DialogService, deps: [{ token: i1.MatSnackBar }, { token: i2.MatDialog }, { token: i3.TranslatePipe }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DialogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.MatSnackBar }, { type: i2.MatDialog }, { type: i3.TranslatePipe }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,198 @@
+import { Injectable, inject } from '@angular/core';
+import { catchError, finalize, forkJoin, map, of, shareReplay } from 'rxjs';
+import { ConfigService } from '../others/config-service';
+import { EnvironmentType } from '../others/environment-type';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth-http.service";
+export class DictionaryService {
+    constructor(http) {
+        this.http = http;
+        this.activeDictionaryRequests = new Map();
+        this.supportsBatchLoad = true;
+        this.configService = inject(ConfigService);
+    }
+    getDictionaries(params) {
+        let url = this.configService.readConfig().baseUrlInfrastructure + '/dictionaries';
+        let query = '';
+        if (params.pageSize) {
+            query += `&PageSize=${params.pageSize}`;
+        }
+        if (params.page) {
+            query += `&PageNumber=${params.page}`;
+        }
+        if (params.sort) {
+            query += `&Sort=${params.sort}`;
+        }
+        if (params.sortDirection) {
+            query += `&SortDirection=${params.sortDirection}`;
+        }
+        if (params.languageIds && params.languageIds.length > 0) {
+            query += `&LanguageIds=${params.languageIds.join('&LanguageIds=')}`;
+        }
+        if (params.dictionaryIds && params.dictionaryIds.length > 0) {
+            query += `&DictionaryIds=${params.dictionaryIds.join('&DictionaryIds=')}`;
+        }
+        if (params.dictionaryUUIDs && params.dictionaryUUIDs.length > 0) {
+            query += `&DictionaryUUIDs=${params.dictionaryUUIDs.join('&DictionaryUUIDs=')}`;
+        }
+        if (params.filters && params.filters.length > 0) {
+            query += `&Filter=${params.filters.join('&Filter=')}`;
+        }
+        const env = params.env || EnvironmentType.Config;
+        query += `&Env=${env}`;
+        if (query.length > 0) {
+            url += '?' + query;
+        }
+        return this.http.get(url);
+    }
+    getDictionariesLight(params) {
+        let url = this.configService.readConfig().baseUrlInfrastructure +
+            '/dictionaries/light';
+        let query = '';
+        if (params.pageSize) {
+            query += `&PageSize=${params.pageSize}`;
+        }
+        if (params.page) {
+            query += `&PageNumber=${params.page}`;
+        }
+        if (params.sort) {
+            query += `&Sort=${params.sort}`;
+        }
+        if (params.sortDirection) {
+            query += `&SortDirection=${params.sortDirection}`;
+        }
+        if (params.languageIds && params.languageIds.length > 0) {
+            query += `&LanguageIds=${params.languageIds.join('&LanguageIds=')}`;
+        }
+        if (params.filters && params.filters.length > 0) {
+            query += `&Filter=${params.filters.join('&Filter=')}`;
+        }
+        const env = params.env || EnvironmentType.Config;
+        query += `&Env=${env}`;
+        if (query.length > 0) {
+            url += '?' + query;
+        }
+        return this.http.get(url);
+    }
+    delete(uuid, env) {
+        const url = this.configService.readConfig().baseUrlInfrastructure +
+            `/dictionaries/${uuid}/${env}`;
+        return this.http.delete(url);
+    }
+    getDictionary(id, env) {
+        const requestKey = `${id}_${env}`;
+        if (this.activeDictionaryRequests.has(requestKey)) {
+            return this.activeDictionaryRequests.get(requestKey);
+        }
+        const url = this.configService.readConfig().baseUrlInfrastructure +
+            '/dictionaries/dictionary/' +
+            id +
+            '/' +
+            env;
+        const newRequest$ = this.http.get(url).pipe(shareReplay(1), finalize(() => {
+            this.activeDictionaryRequests.delete(requestKey);
+        }));
+        this.activeDictionaryRequests.set(requestKey, newRequest$);
+        return newRequest$;
+    }
+    /**
+     * Load multiple dictionaries in parallel
+     * Reusable for any scenario that needs multiple dictionaries
+     */
+    loadMultipleDictionaries(uuids, env = EnvironmentType.Config) {
+        if (uuids.length === 0) {
+            return of(new Map());
+        }
+        // Check if backend supports batch loading
+        if (this.supportsBatchLoad) {
+            return this.getBatchDictionaries(uuids, env);
+        }
+        // Fallback: Load all in parallel instead of sequential
+        const requests = uuids.map((uuid) => this.getDictionary(uuid, env).pipe(map((dict) => ({ uuid, dict })), catchError((error) => {
+            console.warn(`Failed to load dictionary ${uuid}:`, error);
+            return of({ uuid, dict: null });
+        })));
+        return forkJoin(requests).pipe(map((results) => {
+            const dictionaryMap = new Map();
+            results.forEach((result) => {
+                if (result.dict) {
+                    dictionaryMap.set(result.uuid, result.dict);
+                }
+            });
+            return dictionaryMap;
+        }));
+    }
+    /**
+     * Private method for batch loading (when backend supports it)
+     */
+    getBatchDictionaries(uuids, env) {
+        const url = `${this.configService.readConfig().baseUrlInfrastructure}/dictionaries/batch`;
+        return this.http
+            .post(url, { uuids, env })
+            .pipe(map((response) => new Map(Object.entries(response))));
+    }
+    getDependencies(id) {
+        const url = this.configService.readConfig().baseUrlInfrastructure +
+            '/dictionaries/dependencies/' +
+            id;
+        return this.http.get(url);
+    }
+    getAppDependencies(uuid, env) {
+        const url = this.configService.readConfig().baseUrlInfrastructure +
+            '/dictionaries/app-dependencies/' +
+            uuid +
+            '/' +
+            env;
+        return this.http.get(url);
+    }
+    create(dictionary) {
+        const createUrl = this.configService.readConfig().baseUrlInfrastructure + '/dictionaries';
+        return this.http.post(createUrl, dictionary);
+    }
+    updateDictionary(dictionary) {
+        const updateUrl = `${this.configService.readConfig().baseUrlInfrastructure}/dictionaries`;
+        return this.http.put(updateUrl, dictionary);
+    }
+    publishDictionaryVersion(uuid, envFrom, envTo) {
+        const url = this.configService.readConfig().baseUrlInfrastructure +
+            `/dictionaries/publish` +
+            `?uuid=${uuid}&envFrom=${envFrom}&envTo=${envTo}`;
+        return this.http.get(url);
+    }
+    getDictionaryVersion(uuid, env) {
+        const url = this.configService.readConfig().baseUrlInfrastructure +
+            `/dictionaries/dictionary/` +
+            `${uuid}/${env}`;
+        return this.http.get(url);
+    }
+    loadAppDictionaries(appUuid, env = EnvironmentType.Config) {
+        const url = `${this.configService.readConfig().baseUrlInfrastructure}/dictionaries/app-dictionaries/${appUuid}?env=${env}`;
+        return this.http.get(url);
+    }
+    /**
+     * NEW: Get complete dictionary tree in a single API call
+     * This replaces the need for multiple recursive calls to load child dictionaries
+     */
+    getDictionaryTree(dictionaryId, params) {
+        const baseUrl = this.configService.readConfig().baseUrlInfrastructure;
+        let url = `${baseUrl}/dictionaries/${dictionaryId}/tree`;
+        let queryParams = [];
+        queryParams.push(`environmentType=${params.env}`);
+        if (params.languageId) {
+            queryParams.push(`languageId=${params.languageId}`);
+        }
+        if (params.valueIdsToShow && params.valueIdsToShow.length > 0) {
+            queryParams.push(`valueIdsToShow=${params.valueIdsToShow.join(',')}`);
+        }
+        if (queryParams.length > 0) {
+            url += '?' + queryParams.join('&');
+        }
+        return this.http.get(url);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DictionaryService, deps: [{ token: i1.AuthHttpService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DictionaryService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DictionaryService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.AuthHttpService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dictionary.service.js","sourceRoot":"","sources":["../../../../../projects/origin-form/src/lib/services/dictionary.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { catchError, finalize, forkJoin, map, Observable, of, shareReplay } from 'rxjs';\nimport {\n  Dictionary,\n  DictionaryAppDependencyDto,\n  DictionaryDto,\n} from '../models/dictionary.model';\nimport { List } from '../models/list.model';\nimport { ConfigService } from '../others/config-service';\nimport { EnvironmentType } from '../others/environment-type';\nimport { AuthHttpService } from './auth-http.service';\nimport { HttpEvent } from '@angular/common/http';\n\n@Injectable()\nexport class DictionaryService {\n  private activeDictionaryRequests = new Map<\n  string,\n  Observable<DictionaryDto>\n>();\nprivate supportsBatchLoad = true;\n  constructor(private http: AuthHttpService) {}\n\n  configService = inject(ConfigService);\n\n  public getDictionaries(params: {\n    page?: number;\n    pageSize?: number;\n    sort?: string;\n    sortDirection?: string;\n    filters?: string[];\n    dictionaryIds?: number[];\n    dictionaryUUIDs?: string[];\n    languageIds?: number[];\n    env: EnvironmentType;\n  }): Observable<List<DictionaryDto>> {\n    let url =\n      this.configService.readConfig().baseUrlInfrastructure + '/dictionaries';\n\n    let query = '';\n    if (params.pageSize) {\n      query += `&PageSize=${params.pageSize}`;\n    }\n    if (params.page) {\n      query += `&PageNumber=${params.page}`;\n    }\n    if (params.sort) {\n      query += `&Sort=${params.sort}`;\n    }\n    if (params.sortDirection) {\n      query += `&SortDirection=${params.sortDirection}`;\n    }\n    if (params.languageIds && params.languageIds.length > 0) {\n      query += `&LanguageIds=${params.languageIds.join('&LanguageIds=')}`;\n    }\n    if (params.dictionaryIds && params.dictionaryIds.length > 0) {\n      query += `&DictionaryIds=${params.dictionaryIds.join('&DictionaryIds=')}`;\n    }\n    if (params.dictionaryUUIDs && params.dictionaryUUIDs.length > 0) {\n      query += `&DictionaryUUIDs=${params.dictionaryUUIDs.join(\n        '&DictionaryUUIDs='\n      )}`;\n    }\n    if (params.filters && params.filters.length > 0) {\n      query += `&Filter=${params.filters.join('&Filter=')}`;\n    }\n\n    const env = params.env || EnvironmentType.Config;\n    query += `&Env=${env}`;\n\n    if (query.length > 0) {\n      url += '?' + query;\n    }\n\n    return this.http.get<List<DictionaryDto>>(url);\n  }\n\n  public getDictionariesLight(params: {\n    page?: number;\n    pageSize?: number;\n    sort?: string;\n    sortDirection?: string;\n    filters: string[];\n    languageIds?: number[];\n    env: EnvironmentType;\n  }): Observable<List<DictionaryDto>> {\n    let url =\n      this.configService.readConfig().baseUrlInfrastructure +\n      '/dictionaries/light';\n\n    let query = '';\n    if (params.pageSize) {\n      query += `&PageSize=${params.pageSize}`;\n    }\n    if (params.page) {\n      query += `&PageNumber=${params.page}`;\n    }\n    if (params.sort) {\n      query += `&Sort=${params.sort}`;\n    }\n    if (params.sortDirection) {\n      query += `&SortDirection=${params.sortDirection}`;\n    }\n    if (params.languageIds && params.languageIds.length > 0) {\n      query += `&LanguageIds=${params.languageIds.join('&LanguageIds=')}`;\n    }\n    if (params.filters && params.filters.length > 0) {\n      query += `&Filter=${params.filters.join('&Filter=')}`;\n    }\n    const env = params.env || EnvironmentType.Config;\n    query += `&Env=${env}`;\n\n    if (query.length > 0) {\n      url += '?' + query;\n    }\n    return this.http.get<List<DictionaryDto>>(url);\n  }\n\n  public delete(uuid: string, env: string): Observable<any> {\n    const url =\n      this.configService.readConfig().baseUrlInfrastructure +\n      `/dictionaries/${uuid}/${env}`;\n    return this.http.delete(url);\n  }\n\n  public getDictionary(\n    id: string,\n    env: EnvironmentType\n  ): Observable<DictionaryDto> {\n    const requestKey = `${id}_${env}`;\n    if (this.activeDictionaryRequests.has(requestKey)) {\n      return this.activeDictionaryRequests.get(requestKey)!;\n    }\n\n    const url =\n      this.configService.readConfig().baseUrlInfrastructure +\n      '/dictionaries/dictionary/' +\n      id +\n      '/' +\n      env;\n\n    const newRequest$ = this.http.get<DictionaryDto>(url).pipe(\n      shareReplay(1),\n      finalize(() => {\n        this.activeDictionaryRequests.delete(requestKey);\n      })\n    );\n\n    this.activeDictionaryRequests.set(requestKey, newRequest$);\n    return newRequest$;\n  }\n\n  /**\n   * Load multiple dictionaries in parallel\n   * Reusable for any scenario that needs multiple dictionaries\n   */\n  public loadMultipleDictionaries(\n    uuids: string[],\n    env: EnvironmentType = EnvironmentType.Config\n  ): Observable<Map<string, DictionaryDto>> {\n    if (uuids.length === 0) {\n      return of(new Map());\n    }\n\n    // Check if backend supports batch loading\n    if (this.supportsBatchLoad) {\n      return this.getBatchDictionaries(uuids, env);\n    }\n\n    // Fallback: Load all in parallel instead of sequential\n    const requests = uuids.map((uuid) =>\n      this.getDictionary(uuid, env).pipe(\n        map((dict) => ({ uuid, dict })),\n        catchError((error) => {\n          console.warn(`Failed to load dictionary ${uuid}:`, error);\n          return of({ uuid, dict: null });\n        })\n      )\n    );\n\n    return forkJoin(requests).pipe(\n      map((results) => {\n        const dictionaryMap = new Map<string, DictionaryDto>();\n        results.forEach((result) => {\n          if (result.dict) {\n            dictionaryMap.set(result.uuid, result.dict);\n          }\n        });\n        return dictionaryMap;\n      })\n    );\n  }\n\n  /**\n   * Private method for batch loading (when backend supports it)\n   */\n  private getBatchDictionaries(\n    uuids: string[],\n    env: EnvironmentType\n  ): Observable<Map<string, DictionaryDto>> {\n    const url = `${\n      this.configService.readConfig().baseUrlInfrastructure\n    }/dictionaries/batch`;\n    return this.http\n      .post<{ [uuid: string]: DictionaryDto }>(url, { uuids, env })\n      .pipe(map((response) => new Map(Object.entries(response))));\n  }\n\n  public getDependencies(id: number): Observable<DictionaryDto[]> {\n    const url =\n      this.configService.readConfig().baseUrlInfrastructure +\n      '/dictionaries/dependencies/' +\n      id;\n    return this.http.get<DictionaryDto[]>(url);\n  }\n\n  public getAppDependencies(\n    uuid: string,\n    env: EnvironmentType\n  ): Observable<DictionaryAppDependencyDto> {\n    const url =\n      this.configService.readConfig().baseUrlInfrastructure +\n      '/dictionaries/app-dependencies/' +\n      uuid +\n      '/' +\n      env;\n    return this.http.get<DictionaryAppDependencyDto>(url);\n  }\n\n  public create(dictionary: Dictionary): Observable<string> {\n    const createUrl =\n      this.configService.readConfig().baseUrlInfrastructure + '/dictionaries';\n    return this.http.post<string>(createUrl, dictionary);\n  }\n\n  updateDictionary(dictionary: Dictionary): Observable<Dictionary> {\n    const updateUrl = `${\n      this.configService.readConfig().baseUrlInfrastructure\n    }/dictionaries`;\n    return this.http.put<Dictionary>(updateUrl, dictionary);\n  }\n\n  publishDictionaryVersion(\n    uuid: string,\n    envFrom: EnvironmentType,\n    envTo: EnvironmentType\n  ): Observable<DictionaryDto> {\n    const url =\n      this.configService.readConfig().baseUrlInfrastructure +\n      `/dictionaries/publish` +\n      `?uuid=${uuid}&envFrom=${envFrom}&envTo=${envTo}`;\n    return this.http.get<DictionaryDto>(url);\n  }\n\n  getDictionaryVersion(\n    uuid: string,\n    env: EnvironmentType\n  ): Observable<DictionaryDto> {\n    const url =\n      this.configService.readConfig().baseUrlInfrastructure +\n      `/dictionaries/dictionary/` +\n      `${uuid}/${env}`;\n    return this.http.get<DictionaryDto>(url);\n  }\n\n  public loadAppDictionaries(\n    appUuid: string,\n    env: EnvironmentType = EnvironmentType.Config\n  ): Observable<AppDictionariesResponse> {\n    const url = `${\n      this.configService.readConfig().baseUrlInfrastructure\n    }/dictionaries/app-dictionaries/${appUuid}?env=${env}`;\n\n    return this.http.get<AppDictionariesResponse>(url);\n  }\n\n  /**\n   * NEW: Get complete dictionary tree in a single API call\n   * This replaces the need for multiple recursive calls to load child dictionaries\n   */\n  public getDictionaryTree(\n    dictionaryId: string,\n    params: {\n      env: EnvironmentType;\n      languageId?: number;\n      valueIdsToShow?: number[];\n    }\n  ): Observable<DictionaryTreeResponseDto> {\n    const baseUrl = this.configService.readConfig().baseUrlInfrastructure;\n    let url = `${baseUrl}/dictionaries/${dictionaryId}/tree`;\n\n    let queryParams: string[] = [];\n    queryParams.push(`environmentType=${params.env}`);\n\n    if (params.languageId) {\n      queryParams.push(`languageId=${params.languageId}`);\n    }\n\n    if (params.valueIdsToShow && params.valueIdsToShow.length > 0) {\n      queryParams.push(`valueIdsToShow=${params.valueIdsToShow.join(',')}`);\n    }\n\n    if (queryParams.length > 0) {\n      url += '?' + queryParams.join('&');\n    }\n\n    return this.http.get<DictionaryTreeResponseDto>(url);\n  }\n}\n\n// NEW: Response interface for dictionary tree endpoint\nexport interface DictionaryTreeResponseDto {\n  mainDictionary: DictionaryDto;\n  allDictionaries: DictionaryDto[];\n  metadata: {\n    totalDictionaries: number;\n    maxDepth: number;\n    loadedAt: string;\n  };\n}\n\n// Response interface for the app dictionaries endpoint\nexport interface AppDictionariesResponse {\n  dictionaries: { [uuid: string]: DictionaryDto };\n  analysisStats: {\n    appUuid: string;\n    sectionsAnalyzed: number;\n    controlsAnalyzed: number;\n    presentationControlsAnalyzed: number;\n    initialDictionariesFound: number;\n    totalLoaded: number;\n    dependencyRounds: number;\n    loadingTimeMs: number;\n  };\n  success: boolean;\n  errors?: string[];\n}\n"]}

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

@@ -0,0 +1,47 @@
+import { Injectable, inject } from '@angular/core';
+import { ConfigService } from '../others/config-service';
+import { EnvironmentType } from '../others/environment-type';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth-http.service";
+export class FormsService {
+    constructor(http) {
+        this.http = http;
+        this.configService = inject(ConfigService);
+    }
+    loadForm(id, env) {
+        const url = this.configService.readConfig().baseUrlInfrastructure +
+            `/Application/LoadById` +
+            `?id=${id}`;
+        return this.http.get(url);
+    }
+    loadFormByUuid(uuid, env) {
+        if (!env) {
+            env = EnvironmentType.Config;
+        }
+        const url = this.configService.readConfig().baseUrlInfrastructure +
+            `/Application/LoadByUuidAndEnv` +
+            `?uuid=${uuid}&env=${env}`;
+        return this.http.get(url);
+    }
+    publish(applicationUuid, envTo) {
+        const url = this.configService.readConfig().baseUrlInfrastructure +
+            `/Application/Publish` +
+            `?uuid=${applicationUuid}&envFrom=${EnvironmentType.Config}&envTo=${envTo}`;
+        return this.http.get(url);
+    }
+    getVersion(applicationUuid, env) {
+        const url = this.configService.readConfig().baseUrlInfrastructure +
+            `/application/LoadByUuidAndEnv` +
+            `?uuid=${applicationUuid}&env=${env}`;
+        return this.http.get(url);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormsService, deps: [{ token: i1.AuthHttpService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.AuthHttpService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,29 @@
+import { Injectable, inject } from '@angular/core';
+import { ConfigService } from '../others/config-service';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth-http.service";
+export class LabelService {
+    constructor(http) {
+        this.http = http;
+        this.configService = inject(ConfigService);
+    }
+    getLabels(langIso, updateUserLanguageIso = true) {
+        let listUrl = this.configService.readConfig().baseUrlPublicInfrastructure + '/labels';
+        if (langIso) {
+            listUrl += `?&LanguageIso=${langIso}`;
+            if (updateUserLanguageIso == false) {
+                listUrl += '&ShouldUpdateUserLanguage=false';
+            }
+        }
+        return this.http.get(listUrl);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LabelService, deps: [{ token: i1.AuthHttpService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LabelService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LabelService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.AuthHttpService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,24 @@
+import { Injectable, inject } from '@angular/core';
+import { ConfigService } from '../others/config-service';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth-http.service";
+export class LanguageService {
+    constructor(http) {
+        this.http = http;
+        this.configService = inject(ConfigService);
+    }
+    getLanguages() {
+        const url = this.configService.readConfig().baseUrlInfrastructure +
+            '/language?PageSize=999999';
+        return this.http.get(url);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LanguageService, deps: [{ token: i1.AuthHttpService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LanguageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LanguageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.AuthHttpService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFuZ3VhZ2Uuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL29yaWdpbi1mb3JtL3NyYy9saWIvc2VydmljZXMvbGFuZ3VhZ2Uuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUluRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7OztBQU16RCxNQUFNLE9BQU8sZUFBZTtJQUMxQixZQUFvQixJQUFxQjtRQUFyQixTQUFJLEdBQUosSUFBSSxDQUFpQjtRQUV6QyxrQkFBYSxHQUFHLE1BQU0sQ0FBQyxhQUFhLENBQUMsQ0FBQztJQUZNLENBQUM7SUFJN0MsWUFBWTtRQUNWLE1BQU0sR0FBRyxHQUNQLElBQUksQ0FBQyxhQUFhLENBQUMsVUFBVSxFQUFFLENBQUMscUJBQXFCO1lBQ3JELDJCQUEyQixDQUFDO1FBQzlCLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQWlCLEdBQUcsQ0FBQyxDQUFDO0lBQzVDLENBQUM7K0dBVlUsZUFBZTttSEFBZixlQUFlLGNBRmQsTUFBTTs7NEZBRVAsZUFBZTtrQkFIM0IsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlLCBpbmplY3QgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IExpc3QgfSBmcm9tICcuLi9tb2RlbHMvbGlzdC5tb2RlbCc7XG5pbXBvcnQgeyBMYW5ndWFnZSB9IGZyb20gJy4uL21vZGVscy9sYW5ndWFnZS5tb2RlbCc7XG5pbXBvcnQgeyBDb25maWdTZXJ2aWNlIH0gZnJvbSAnLi4vb3RoZXJzL2NvbmZpZy1zZXJ2aWNlJztcbmltcG9ydCB7IEF1dGhIdHRwU2VydmljZSB9IGZyb20gJy4vYXV0aC1odHRwLnNlcnZpY2UnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgTGFuZ3VhZ2VTZXJ2aWNlIHtcbiAgY29uc3RydWN0b3IocHJpdmF0ZSBodHRwOiBBdXRoSHR0cFNlcnZpY2UpIHt9XG5cbiAgY29uZmlnU2VydmljZSA9IGluamVjdChDb25maWdTZXJ2aWNlKTtcblxuICBnZXRMYW5ndWFnZXMoKTogT2JzZXJ2YWJsZTxMaXN0PExhbmd1YWdlPj4ge1xuICAgIGNvbnN0IHVybCA9XG4gICAgICB0aGlzLmNvbmZpZ1NlcnZpY2UucmVhZENvbmZpZygpLmJhc2VVcmxJbmZyYXN0cnVjdHVyZSArXG4gICAgICAnL2xhbmd1YWdlP1BhZ2VTaXplPTk5OTk5OSc7XG4gICAgcmV0dXJuIHRoaXMuaHR0cC5nZXQ8TGlzdDxMYW5ndWFnZT4+KHVybCk7XG4gIH1cbn1cbiJdfQ==