@tsi-developpement/tsi-shared-ui 0.0.1

package/esm2022/lib/services/authorization/identity-manager.service.mjs

@@ -0,0 +1,97 @@
+import { Injectable } from '@angular/core';
+import { authorization, menuItems, userLanguage } from '../../consts/tsi-consts';
+// import { AuthorizationToken } from '@shared/models/authorization/authorization-token';
+// import { AuthorizationTokenMapper } from '@shared/models/authorization/authorization-token-mapper';
+import { StorageManager } from '../../tsi-helpers/storage-manager';
+import { rtlModeKeys } from '../../consts/locals.const';
+import { AuthorizationTokenMapper } from '../../models';
+import * as i0 from "@angular/core";
+import * as i1 from "@auth0/angular-jwt";
+// import { AppConsts } from 'app/app-consts';
+export class IdentityManagerService {
+    constructor(_jwtHelper) {
+        this._jwtHelper = _jwtHelper;
+    }
+    saveAuthToken(token) {
+        StorageManager.setItem(authorization.encryptedAuthTokenName, token);
+    }
+    saveRtlMode(value) {
+        StorageManager.setItem(rtlModeKeys.rtlModeEnabled, value);
+    }
+    saveUserLanguage(value) {
+        StorageManager.setItem(userLanguage.userLanguage, value);
+    }
+    getUserLanguage() {
+        return StorageManager.getItem(userLanguage.userLanguage);
+    }
+    saveMenuItems(values) {
+        StorageManager.setItem(menuItems.menuItems, values);
+    }
+    // public saveConnectionString(connectionString : string){
+    //   StorageManager.setItem(AppConsts.connectionString.connectionString, connectionString)
+    // }
+    // public getConnectionString(){
+    //   return StorageManager.getItem(AppConsts.connectionString.connectionString)
+    // }
+    getAuthToken() {
+        return StorageManager.getItem(authorization.encryptedAuthTokenName);
+    }
+    getMenuItems() {
+        return StorageManager.getItem(menuItems.menuItems);
+    }
+    getRtlMode() {
+        return StorageManager.getItem(rtlModeKeys.rtlModeEnabled);
+    }
+    removeAuthToken() {
+        StorageManager.removeItem(authorization.encryptedAuthTokenName);
+    }
+    iHaveAuthToken() {
+        if (this.getAuthToken()) {
+            return true;
+        }
+        return false;
+    }
+    isMyAuthTokenValid() {
+        if (this.iHaveAuthToken()) {
+            let myAuthToken = this.getAuthToken();
+            return this.isAuthTokenValid(myAuthToken);
+        }
+        else {
+            return false;
+        }
+    }
+    isAuthTokenValid(token) {
+        if (token) {
+            return !this._jwtHelper.isTokenExpired(token);
+        }
+        return false;
+    }
+    parseAuthToken(token) {
+        if (token) {
+            let parseToken = this._jwtHelper.decodeToken(token);
+            return AuthorizationTokenMapper.ToAuthorizationToken(parseToken);
+        }
+        else {
+            return undefined;
+        }
+    }
+    parseMyAuthToken() {
+        let myToken = this.getAuthToken();
+        if (this.iHaveAuthToken() && myToken) {
+            let parseToken = this._jwtHelper.decodeToken(myToken);
+            return AuthorizationTokenMapper.ToAuthorizationToken(parseToken);
+        }
+        else {
+            throw new Error('no auth token found for current user !');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IdentityManagerService, deps: [{ token: i1.JwtHelperService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IdentityManagerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IdentityManagerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.JwtHelperService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/base/crud-base.service.mjs

@@ -0,0 +1,38 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Segment } from '../../end-points';
+import { requestHeaderNames } from '../../consts/tsi-consts';
+export class CrudBaseService {
+    constructor(_httpClient, endpoint) {
+        this._httpClient = _httpClient;
+        this.endpoint = endpoint;
+        this.isDuplicate = false;
+    }
+    getAll() {
+        return this._httpClient.get(`${Segment.base}/${this.endpoint}`);
+    }
+    getById(id) {
+        let headers = new HttpHeaders();
+        headers = headers.set(requestHeaderNames.duplicate, this.isDuplicate ? "true" : "false");
+        return this._httpClient.get(`${Segment.base}/${this.endpoint}/${id}`, { headers });
+    }
+    create(model) {
+        return this._httpClient.post(`${Segment.base}/${this.endpoint}`, model);
+    }
+    update(model, id) {
+        return this._httpClient.put(`${Segment.base}/${this.endpoint}/${id}`, model);
+    }
+    delete(id) {
+        return this._httpClient.delete(`${Segment.base}/${this.endpoint}/${id}`);
+    }
+    getAllPaged(model) {
+        return this._httpClient.post(`${Segment.base}/${this.endpoint}/${Segments.getAllPaged}`, model);
+    }
+    updateOldEndpoint(model) {
+        return this._httpClient.put(`${Segment.base}/${this.endpoint}/${'update'}`, model);
+    }
+}
+export const Segments = {
+    /***    Actions ***/
+    getAllPaged: 'getallpaged',
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/configuration/entity-configuration.service.mjs

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import { firstValueFrom } from 'rxjs';
+import { AdministrationEndpoints } from '../../end-points/endpoints';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class EntityConfigurationService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.entityInformationsDictionnary = new Map();
+    }
+    getEntityInfo(businessClassName) {
+        return this.httpClient.get(AdministrationEndpoints.getEntityInformations(businessClassName));
+    }
+    async getEntityInfoFromCache(businessClassName) {
+        const entityInfo = this.entityInformationsDictionnary.get(businessClassName);
+        if (!entityInfo) {
+            let tmp = await firstValueFrom(this.getEntityInfo(businessClassName));
+            this.entityInformationsDictionnary.set(businessClassName, tmp);
+        }
+        return this.entityInformationsDictionnary.get(businessClassName);
+    }
+    GetAllEntityInfos() {
+        return this.httpClient.get(AdministrationEndpoints.GetAllEntitiesInformations());
+    }
+    getEntityInformationsAndRelations(businessClass) {
+        return this.httpClient.get(AdministrationEndpoints.getEntityInformationsAndRelations(businessClass));
+    }
+    create(entityInfoWithRelations) {
+        return this.httpClient.post(AdministrationEndpoints.createOrUpdateEntityInformations(), entityInfoWithRelations);
+    }
+    update(updateEntityInfoWithRelationsRequest) {
+        return this.httpClient.put(AdministrationEndpoints.createOrUpdateEntityInformations(), updateEntityInfoWithRelationsRequest);
+    }
+    delete(className) {
+        return this.httpClient.delete(AdministrationEndpoints.deleteEntityInformations(className));
+    }
+    getColonnesByClassNameAsKeyValuePair(className) {
+        return this.httpClient.get(AdministrationEndpoints.getColonnesByClassNameAsKeyValuePair(className, ""));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EntityConfigurationService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EntityConfigurationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EntityConfigurationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, firstValueFrom } from 'rxjs';
+import { AdministrationEndpoints } from '../../end-points/endpoints';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class CurrentUserService {
+    constructor(http) {
+        this.http = http;
+        this._currentUser$ = new BehaviorSubject(null);
+        this._currentUserLoaded = false;
+    }
+    async loadCurrentUser() {
+        if (!this._currentUserLoaded) {
+            try {
+                this._currentUser = await firstValueFrom(this.http.get(AdministrationEndpoints.GetCurrentUserWithRoles()));
+                this._currentUser$.next(this._currentUser);
+                this._currentUserLoaded = true;
+            }
+            catch (err) {
+                console.error(err);
+            }
+        }
+        return this._currentUser;
+    }
+    get currentUser() {
+        return this._currentUser;
+    }
+    async getPersonne() {
+        await this.loadCurrentUser();
+        return this._currentUser?.personne ?? null;
+    }
+    async getClient() {
+        await this.loadCurrentUser();
+        return this._currentUser?.client ?? null;
+    }
+    async getFournisseur() {
+        await this.loadCurrentUser();
+        return this._currentUser?.fournisseur ?? null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CurrentUserService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CurrentUserService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CurrentUserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/date-helper.service.mjs

@@ -0,0 +1,133 @@
+import { Injectable } from '@angular/core';
+import { DateFormat, DateTimeFormat, TimeFormat } from '../consts/tsi-consts';
+import { TimeOnly } from '../types/time-only';
+import * as i0 from "@angular/core";
+export class DateHelperService {
+    constructor() {
+        this.dateFormat = DateFormat;
+        this.dateTimeFormat = DateTimeFormat;
+        this.timeFormat = TimeFormat;
+    }
+    /**
+     * Converts a string to a Date by using the specified locale UTC and format DateFormat.
+     * @param dateString A string date in format DateFormat
+      */
+    parseDateString(dateString) {
+        const [day, month, year] = dateString.split('/').map(Number);
+        // Subtract 1 from month since it's zero-based in JavaScript's Date object
+        const date = new Date(Date.UTC(year, month - 1, day, 0, 0, 0, 0));
+        // Check if the parsed date is valid
+        if (date.getFullYear() === year &&
+            date.getMonth() === month - 1 &&
+            date.getDate() === day) {
+            return date;
+        }
+        return undefined; // Return undefined if the date string is invalid
+    }
+    /**
+     * Converts a string to a Date by using the specified locale UTC and format DateTimeFormat.
+     * @param dateString A string date in format DateTimeFormat
+      */
+    parseDateTimeString(dateString) {
+        const [datePart, timePart] = dateString.split(' ').map(String);
+        const [day, month, year] = datePart.split('/').map(Number);
+        const [hour, minute, second] = timePart.split(':').map(Number);
+        // Subtract 1 from month since it's zero-based in JavaScript's Date object
+        const date = new Date(Date.UTC(year, month - 1, day, hour, minute, second, 0));
+        // Check if the parsed date is valid
+        if (date.getUTCFullYear() === year &&
+            date.getUTCMonth() === month - 1 &&
+            date.getUTCDate() === day &&
+            date.getUTCHours() === hour &&
+            date.getUTCMinutes() === minute &&
+            date.getUTCSeconds() === second) {
+            return date;
+        }
+        return undefined; // Return undefined if the date string is invalid
+    }
+    /**
+     * Converts a string to a TimeOnly by using the format DateTimeFormat.
+     * @param timeString A string timeonly in format TimeFormat
+      */
+    parseTimeString(timeString) {
+        const [hour, minute, second] = timeString.split(':').map(Number);
+        const time = new TimeOnly(hour, minute, second, 0);
+        // Check if the parsed date is valid
+        if (time.getHours() === hour &&
+            time.getMinutes() === minute &&
+            time.getSeconds() === second &&
+            time.getMilliseconds() === 0) {
+            return time;
+        }
+        return undefined; // Return undefined if the date string is invalid
+    }
+    createUtcDateFromDate(value) {
+        if (!(value instanceof Date)) {
+            throw new Error('Provided value is not instanceof Date');
+        }
+        let newDate = new Date(value);
+        const [year, month, day, hour, minute, second] = [
+            newDate.getFullYear(),
+            newDate.getMonth(),
+            newDate.getDate(),
+            newDate.getHours(),
+            newDate.getMinutes(),
+            newDate.getSeconds(),
+        ];
+        const date = new Date(Date.UTC(year, month, day, hour, minute, second, 0));
+        // Check if the parsed date is valid
+        if (date.getUTCFullYear() === year &&
+            date.getUTCMonth() === month &&
+            date.getUTCDate() === day &&
+            date.getUTCHours() === hour &&
+            date.getUTCMinutes() === minute &&
+            date.getUTCSeconds() === second) {
+            return date;
+        }
+        return undefined; // Return undefined if the date string is invalid
+    }
+    /**
+     * Converts a jsonString to a Date by using the specified locale UTC.
+     * @param jsonString A json string date gotten from remote api
+      */
+    createUtcDateFromString(jsonString) {
+        if (!(typeof jsonString == 'string')) {
+            throw new Error('Provided value is not of type string');
+        }
+        let newDate = new Date(jsonString);
+        const [year, month, day, hour, minute, second] = [
+            newDate.getFullYear(),
+            newDate.getMonth(),
+            newDate.getDate(),
+            newDate.getHours(),
+            newDate.getMinutes(),
+            newDate.getSeconds(),
+        ];
+        const date = new Date(Date.UTC(year, month, day, hour, minute, second, 0));
+        // Check if the parsed date is valid
+        if (date.getUTCFullYear() === year &&
+            date.getUTCMonth() === month &&
+            date.getUTCDate() === day &&
+            date.getUTCHours() === hour &&
+            date.getUTCMinutes() === minute &&
+            date.getUTCSeconds() === second) {
+            return date;
+        }
+        return undefined; // Return undefined if the date string is invalid
+    }
+    extractTimeFromDate(value) {
+        let hour = value.getHours();
+        let minutes = value.getMinutes();
+        let seconds = value.getSeconds();
+        return `${hour}:${minutes}:${seconds}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DateHelperService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DateHelperService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DateHelperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-helper.service.js","sourceRoot":"","sources":["../../../../../projects/tsi-shared-ui/src/lib/services/date-helper.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { DateFormat, DateTimeFormat, TimeFormat } from '../consts/tsi-consts';\r\nimport { TimeOnly } from '../types/time-only';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class DateHelperService {\r\n  dateFormat: string = DateFormat;\r\n  dateTimeFormat: string = DateTimeFormat;\r\n  timeFormat: string = TimeFormat;\r\n\r\n  constructor() { }\r\n\r\n  /**\r\n   * Converts a string to a Date by using the specified locale UTC and format DateFormat.\r\n   * @param dateString A string date in format DateFormat\r\n    */\r\n  public parseDateString(dateString: string): Date | undefined {\r\n    const [day, month, year] = dateString.split('/').map(Number);\r\n\r\n    // Subtract 1 from month since it's zero-based in JavaScript's Date object\r\n    const date = new Date(Date.UTC(year, month - 1, day, 0, 0, 0, 0));\r\n\r\n    // Check if the parsed date is valid\r\n    if (\r\n      date.getFullYear() === year &&\r\n      date.getMonth() === month - 1 &&\r\n      date.getDate() === day\r\n    ) {\r\n      return date;\r\n    }\r\n\r\n    return undefined; // Return undefined if the date string is invalid\r\n  }\r\n\r\n  /**\r\n   * Converts a string to a Date by using the specified locale UTC and format DateTimeFormat.\r\n   * @param dateString A string date in format DateTimeFormat\r\n    */\r\n  public parseDateTimeString(dateString: string): Date | undefined {\r\n    const [datePart, timePart] = dateString.split(' ').map(String);\r\n    const [day, month, year] = datePart.split('/').map(Number);\r\n    const [hour, minute, second] = timePart.split(':').map(Number);\r\n\r\n    // Subtract 1 from month since it's zero-based in JavaScript's Date object\r\n    const date = new Date(Date.UTC(year, month - 1, day, hour, minute, second, 0));\r\n\r\n    // Check if the parsed date is valid\r\n    if (\r\n      date.getUTCFullYear() === year &&\r\n      date.getUTCMonth() === month - 1 &&\r\n      date.getUTCDate() === day &&\r\n      date.getUTCHours() === hour &&\r\n      date.getUTCMinutes() === minute &&\r\n      date.getUTCSeconds() === second\r\n    ) {\r\n      return date;\r\n    }\r\n\r\n    return undefined; // Return undefined if the date string is invalid\r\n  }\r\n\r\n  /**\r\n   * Converts a string to a TimeOnly by using the format DateTimeFormat.\r\n   * @param timeString A string timeonly in format TimeFormat\r\n    */\r\n  public parseTimeString(timeString: string): TimeOnly | undefined {\r\n    const [hour, minute, second] = timeString.split(':').map(Number);\r\n\r\n    const time = new TimeOnly(hour, minute, second, 0);\r\n\r\n    // Check if the parsed date is valid\r\n    if (\r\n      time.getHours() === hour &&\r\n      time.getMinutes() === minute &&\r\n      time.getSeconds() === second &&\r\n      time.getMilliseconds() === 0\r\n    ) {\r\n      return time;\r\n    }\r\n\r\n    return undefined; // Return undefined if the date string is invalid\r\n  }\r\n\r\n  public createUtcDateFromDate(value: Date): Date | undefined {\r\n    if (!(value instanceof Date)) {\r\n      throw new Error('Provided value is not instanceof Date')\r\n    }\r\n\r\n    let newDate = new Date(value);\r\n    const [year, month, day, hour, minute, second] = [\r\n      newDate.getFullYear(),\r\n      newDate.getMonth(),\r\n      newDate.getDate(),\r\n      newDate.getHours(),\r\n      newDate.getMinutes(),\r\n      newDate.getSeconds(),\r\n    ];\r\n\r\n    const date = new Date(Date.UTC(year, month, day, hour, minute, second, 0));\r\n\r\n    // Check if the parsed date is valid\r\n    if (\r\n      date.getUTCFullYear() === year &&\r\n      date.getUTCMonth() === month &&\r\n      date.getUTCDate() === day &&\r\n      date.getUTCHours() === hour &&\r\n      date.getUTCMinutes() === minute &&\r\n      date.getUTCSeconds() === second\r\n    ) {\r\n      return date;\r\n    }\r\n\r\n    return undefined; // Return undefined if the date string is invalid\r\n  }\r\n\r\n  /**\r\n   * Converts a jsonString to a Date by using the specified locale UTC.\r\n   * @param jsonString A json string date gotten from remote api\r\n    */\r\n  public createUtcDateFromString(jsonString: string): Date | undefined {\r\n    if (!(typeof jsonString == 'string')) {\r\n      throw new Error('Provided value is not of type string')\r\n    }\r\n\r\n    let newDate = new Date(jsonString);\r\n    const [year, month, day, hour, minute, second] = [\r\n      newDate.getFullYear(),\r\n      newDate.getMonth(),\r\n      newDate.getDate(),\r\n      newDate.getHours(),\r\n      newDate.getMinutes(),\r\n      newDate.getSeconds(),\r\n    ];\r\n\r\n    const date = new Date(Date.UTC(year, month, day, hour, minute, second, 0));\r\n\r\n    // Check if the parsed date is valid\r\n    if (\r\n      date.getUTCFullYear() === year &&\r\n      date.getUTCMonth() === month &&\r\n      date.getUTCDate() === day &&\r\n      date.getUTCHours() === hour &&\r\n      date.getUTCMinutes() === minute &&\r\n      date.getUTCSeconds() === second\r\n    ) {\r\n      return date;\r\n    }\r\n\r\n    return undefined; // Return undefined if the date string is invalid\r\n  }\r\n\r\n  public extractTimeFromDate(value : Date) : string {\r\n    let hour = value.getHours()\r\n    let minutes = value.getMinutes()\r\n    let seconds = value.getSeconds()\r\n\r\n    return `${hour}:${minutes}:${seconds}`\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class DialogDataService {
+    constructor() {
+        this.eventSubject = new Subject();
+    }
+    sendEvent(data) {
+        this.eventSubject.next(data);
+    }
+    getEvent() {
+        return this.eventSubject.asObservable();
+    }
+    setData(data) {
+        this.data = data;
+    }
+    getData() {
+        return this.data;
+    }
+    clearData() {
+        this.data = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogDataService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogDataService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DialogDataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlhbG9nLWRhdGEuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3RzaS1zaGFyZWQtdWkvc3JjL2xpYi9zZXJ2aWNlcy9kaWFsb2ctZGF0YS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLE1BQU0sQ0FBQzs7QUFLL0IsTUFBTSxPQUFPLGlCQUFpQjtJQUg5QjtRQU1VLGlCQUFZLEdBQUcsSUFBSSxPQUFPLEVBQU8sQ0FBQztLQXNCM0M7SUFwQkMsU0FBUyxDQUFDLElBQVM7UUFDakIsSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDL0IsQ0FBQztJQUVELFFBQVE7UUFDTixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDMUMsQ0FBQztJQUdELE9BQU8sQ0FBQyxJQUFTO1FBQ2YsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7SUFDbkIsQ0FBQztJQUVELE9BQU87UUFDTCxPQUFPLElBQUksQ0FBQyxJQUFJLENBQUM7SUFDbkIsQ0FBQztJQUVELFNBQVM7UUFDUCxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztJQUNuQixDQUFDOytHQXhCVSxpQkFBaUI7bUhBQWpCLGlCQUFpQixjQUZoQixNQUFNOzs0RkFFUCxpQkFBaUI7a0JBSDdCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBTdWJqZWN0IH0gZnJvbSAncnhqcyc7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBEaWFsb2dEYXRhU2VydmljZSB7XHJcblxyXG4gIHByaXZhdGUgZGF0YTogYW55O1xyXG4gIHByaXZhdGUgZXZlbnRTdWJqZWN0ID0gbmV3IFN1YmplY3Q8YW55PigpO1xyXG5cclxuICBzZW5kRXZlbnQoZGF0YTogYW55KSB7XHJcbiAgICB0aGlzLmV2ZW50U3ViamVjdC5uZXh0KGRhdGEpO1xyXG4gIH1cclxuXHJcbiAgZ2V0RXZlbnQoKSB7XHJcbiAgICByZXR1cm4gdGhpcy5ldmVudFN1YmplY3QuYXNPYnNlcnZhYmxlKCk7XHJcbiAgfVxyXG5cclxuXHJcbiAgc2V0RGF0YShkYXRhOiBhbnkpIHtcclxuICAgIHRoaXMuZGF0YSA9IGRhdGE7XHJcbiAgfVxyXG5cclxuICBnZXREYXRhKCk6IGFueSB7XHJcbiAgICByZXR1cm4gdGhpcy5kYXRhO1xyXG4gIH1cclxuXHJcbiAgY2xlYXJEYXRhKCkge1xyXG4gICAgdGhpcy5kYXRhID0gbnVsbDtcclxuICB9XHJcbn1cclxuIl19

package/esm2022/lib/services/fichier/fichier-upload.service.mjs

@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core';
+import { CrudBaseService, Segments } from '../base/crud-base.service';
+import { AdministrationSegments } from '../../end-points/endpoints';
+import { Segment } from '../../end-points';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../dialog-data.service";
+export class FichierUploadService extends CrudBaseService {
+    constructor(httpClient, dialogDataService) {
+        super(httpClient, AdministrationSegments.fichier);
+        this.httpClient = httpClient;
+        this.dialogDataService = dialogDataService;
+    }
+    getAllPaged(model) {
+        return this._httpClient.post(`${Segment.base}/${this.endpoint}/${Segments.getAllPaged}`, {
+            "maxResultCount": 10,
+            "skipCount": 0,
+            "sorting": [],
+            "filters": [
+                {
+                    "operator": 0,
+                    "filterValue": `${this.dialogDataService.getData().class}`,
+                    "propretyName": "TableLiee"
+                },
+                {
+                    "operator": 0,
+                    "filterValue": `${this.dialogDataService.getData().id}`,
+                    "propretyName": "Pkey"
+                }
+            ],
+            "getAllData": false,
+            "summaries": []
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FichierUploadService, deps: [{ token: i1.HttpClient }, { token: i2.DialogDataService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FichierUploadService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FichierUploadService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.DialogDataService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,20 @@
+import { Injectable } from '@angular/core';
+import { CrudBaseService } from '../base/crud-base.service';
+import { AdministrationSegments } from '../../end-points/endpoints';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class FichierService extends CrudBaseService {
+    constructor(httpClient) {
+        super(httpClient, AdministrationSegments.fichier);
+        this.httpClient = httpClient;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FichierService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FichierService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FichierService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmljaGllci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHNpLXNoYXJlZC11aS9zcmMvbGliL3NlcnZpY2VzL2ZpY2hpZXIvZmljaGllci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBRTVELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLDRCQUE0QixDQUFDOzs7QUFLcEUsTUFBTSxPQUFPLGNBQWUsU0FBUSxlQUFtRDtJQUVyRixZQUFzQixVQUFzQjtRQUMxQyxLQUFLLENBQUMsVUFBVSxFQUFFLHNCQUFzQixDQUFDLE9BQU8sQ0FBQyxDQUFBO1FBRDdCLGVBQVUsR0FBVixVQUFVLENBQVk7SUFFNUMsQ0FBQzsrR0FKVSxjQUFjO21IQUFkLGNBQWMsY0FGYixNQUFNOzs0RkFFUCxjQUFjO2tCQUgxQixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEh0dHBDbGllbnQgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XHJcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQ3J1ZEJhc2VTZXJ2aWNlIH0gZnJvbSAnLi4vYmFzZS9jcnVkLWJhc2Uuc2VydmljZSc7XHJcbmltcG9ydCB7IEZpY2hpZXIgfSBmcm9tICcuLi8uLi9tb2RlbHMnO1xyXG5pbXBvcnQgeyBBZG1pbmlzdHJhdGlvblNlZ21lbnRzIH0gZnJvbSAnLi4vLi4vZW5kLXBvaW50cy9lbmRwb2ludHMnO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgRmljaGllclNlcnZpY2UgZXh0ZW5kcyBDcnVkQmFzZVNlcnZpY2U8RmljaGllciwgRmljaGllciwgRmljaGllciwgRmljaGllcj4ge1xyXG5cclxuICBjb25zdHJ1Y3Rvcihwcm90ZWN0ZWQgaHR0cENsaWVudDogSHR0cENsaWVudCkge1xyXG4gICAgc3VwZXIoaHR0cENsaWVudCwgQWRtaW5pc3RyYXRpb25TZWdtZW50cy5maWNoaWVyKVxyXG4gIH1cclxuXHJcbn0iXX0=

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

@@ -0,0 +1,20 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class FormulaService {
+    constructor(_httpClient) {
+        this._httpClient = _httpClient;
+    }
+    getFormulaSuggestions(endpoint, term) {
+        return this._httpClient.get(`${endpoint}/${term}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FormulaService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FormulaService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FormulaService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybXVsYS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHNpLXNoYXJlZC11aS9zcmMvbGliL3NlcnZpY2VzL2Zvcm11bGEuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7QUFNM0MsTUFBTSxPQUFPLGNBQWM7SUFFekIsWUFBb0IsV0FBdUI7UUFBdkIsZ0JBQVcsR0FBWCxXQUFXLENBQVk7SUFBSSxDQUFDO0lBRXZDLHFCQUFxQixDQUFDLFFBQWlCLEVBQUUsSUFBYTtRQUMzRCxPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsR0FBRyxDQUFNLEdBQUcsUUFBUSxJQUFJLElBQUksRUFBRSxDQUFDLENBQUM7SUFDMUQsQ0FBQzsrR0FOUSxjQUFjO21IQUFkLGNBQWMsY0FGYixNQUFNOzs0RkFFUCxjQUFjO2tCQUgxQixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEh0dHBDbGllbnQgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XHJcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgT2JzZXJ2YWJsZX0gZnJvbSAncnhqcyc7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBGb3JtdWxhU2VydmljZSB7XHJcblxyXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgX2h0dHBDbGllbnQ6IEh0dHBDbGllbnQpIHsgfVxyXG4gIFxyXG4gICAgcHVibGljIGdldEZvcm11bGFTdWdnZXN0aW9ucyhlbmRwb2ludCA6IHN0cmluZywgdGVybSA6IHN0cmluZyk6IE9ic2VydmFibGU8YW55PiB7XHJcbiAgICAgIHJldHVybiB0aGlzLl9odHRwQ2xpZW50LmdldDxhbnk+KGAke2VuZHBvaW50fS8ke3Rlcm19YCk7XHJcbiAgICB9XHJcbn1cclxuIl19