@acorex/modules 18.0.9 → 18.0.11

package/fesm2022/acorex-modules-backend.mjs

@@ -1,157 +1,22 @@
-import * as i1$1 from '@acorex/modules/auth';
+import * as i2 from '@acorex/modules/auth';
 import { AXM_AUTH_CONFIG_TOKEN, AXMAuthModule } from '@acorex/modules/auth';
-import * as i2$1 from '@acorex/platform/auth';
+import * as i3 from '@acorex/platform/auth';
 import { AXPSessionService, AXP_TENANT_LOADER, AXP_APPLICATION_LOADER, AXP_PERMISSION_LOADER, AXP_FEATURE_LOADER, AXPAuthModule } from '@acorex/platform/auth';
 import { AXP_ROOT_CONFIG_TOKEN, AXPDataProvider } from '@acorex/platform/common';
+import { AXPFileManagementService } from '@acorex/platform/widgets';
 import * as i0 from '@angular/core';
-import { inject, Injectable, Inject, Injector, Component, NgModule } from '@angular/core';
-import * as i2 from '@angular/router';
+import { inject, Injectable, Component, NgModule } from '@angular/core';
+import * as i1$1 from '@angular/router';
 import { ROUTES } from '@angular/router';
 import * as i1 from '@angular/common/http';
-import { HttpParams } from '@angular/common/http';
-import { firstValueFrom, map, BehaviorSubject, tap, filter, take, of, switchMap, delay } from 'rxjs';
-import { UserManager, WebStorageStateStore } from 'oidc-client-ts';
+import { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';
+import { map, BehaviorSubject, tap, filter, take, of, switchMap, delay, firstValueFrom, Observable } from 'rxjs';
+import * as i1$3 from 'angular-oauth2-oidc';
+import { OAuthService, OAuthModule } from 'angular-oauth2-oidc';
+import { AXNetworkService, AXUploadStatus, AXDownloadStatus } from '@acorex/core/network';
 import { get, isNil, isEmpty, endsWith, startsWith, includes, lte, gte, lt, gt, isEqual, orderBy } from 'lodash-es';
 import * as i1$2 from '@acorex/platform/mocks';
 
-class AXMBackendDataProvider {
-    constructor(http) {
-        this.http = http;
-        this.configs = inject(AXP_ROOT_CONFIG_TOKEN);
-        this.mainUrl = this.configs.baseUrl;
-    }
-    insertOne(entity, entityItem) {
-        const url = `${this.mainUrl}${entity.area ? '/' + entity.area : ''}/${entity.module}/${entity.name}`;
-        return firstValueFrom(this.http.post(url, entityItem));
-    }
-    insertMany(entity, entityList) {
-        const promises = entityList.map((entity) => {
-            const url = `${this.mainUrl}${entity.area ? '/' + entity.area : ''}/${entity.module}/${entity.name}`;
-            return firstValueFrom(this.http.post(url, entity));
-        });
-        return Promise.all(promises);
-    }
-    getOne(entity, id) {
-        const url = `${this.mainUrl}${entity.area ? '/' + entity.area : ''}/${entity.module}/${entity.name}${id ? '/' + id : ''}`;
-        return firstValueFrom(this.http.get(url));
-    }
-    getMany(entity, params) {
-        let httpParams = new HttpParams().set('Skip', params?.skip?.toString() ?? '0').set('Take', params?.take?.toString() ?? '10');
-        if (params?.sort && params?.sort.length > 0) {
-            const sortParam = params?.sort.map((sort) => `${sort.field}:${sort.dir}`).join(',');
-            httpParams = httpParams.set('$orderby', sortParam);
-        }
-        const buildFilterString = (filters) => {
-            return filters
-                .map((f) => {
-                if (f.filters) {
-                    return buildFilterString(f.filters);
-                }
-                else {
-                    return `${f.field} ${f.operator.type} ${f.value}`;
-                }
-            })
-                .join(',');
-        };
-        let filterString = params?.customFilter ? params.customFilter : '';
-        if (params?.filter) {
-            const filter = params.filter;
-            if (filter.filters) {
-                // Construct filter string from provided filters
-                const dynamicFilters = buildFilterString(filter.filters);
-                // Append dynamic filters to custom filter, if both exist
-                filterString = filterString ? `${filterString},${dynamicFilters}` : dynamicFilters;
-            }
-        }
-        // Set the $filter parameter if there are any filters
-        if (filterString) {
-            httpParams = httpParams.set('$filter', filterString);
-        }
-        function capitalizeFirstLetter(str) {
-            return str ? str.charAt(0).toUpperCase() + str.slice(1) : str;
-        }
-        function generateQueryString(filter) {
-            if (!filter.filters) {
-                // Base case: single filter
-                return `${capitalizeFirstLetter(filter.field)} ${filter.operator.type} ${filter.value}`;
-            }
-            else if (!filter.filters.length) {
-                return;
-            }
-            else {
-                // Recursive case: multiple filters
-                const filterStrings = filter.filters.map((subFilter) => generateQueryString(subFilter));
-                const logic = filter.logic || 'AND'; // Default logic is 'AND' if not provided
-                return `${filterStrings.filter((i) => i).join(` ${logic} `)}`;
-            }
-        }
-        let queryString = params?.customFilter ? params.customFilter : '';
-        if (params?.filter) {
-            const filter = params.filter;
-            if (filter.filters && filter.filters.length > 0) {
-                // Construct filter string from provided filters
-                const dynamicQueries = generateQueryString(filter);
-                console.log({ dynamicQueries: dynamicQueries });
-                // Append dynamic filters to custom filter, if both exist
-                queryString = queryString ? `${queryString},${dynamicQueries}` : dynamicQueries;
-            }
-        }
-        // Set the $filter parameter if there are any filters
-        if (queryString) {
-            httpParams = httpParams.set('$query', queryString);
-        }
-        return firstValueFrom(this.http.get(`${this.mainUrl}${entity.area ? '/' + entity.area : ''}/${entity.module}/${params?.costumGetter ? params.costumGetter : entity.name}/${params?.sub ? params.sub : ''}`, { params: httpParams })).then((response) => {
-            return {
-                total: response.totalCount,
-                items: response.items,
-            };
-        });
-    }
-    updateOne(entity, id, data) {
-        const url = `${this.mainUrl}${entity.area ? '/' + entity.area : ''}/${entity.module}/${entity.name}${id ? '/' + id : ''}`;
-        return firstValueFrom(this.http.put(url, data));
-    }
-    deleteOne(entity, id) {
-        const url = `${this.mainUrl}${entity.area ? '/' + entity.area : ''}/${entity.module}/${entity.name}/${id}`;
-        return firstValueFrom(this.http.delete(url));
-    }
-    getFirst(entity) {
-        // return this.getMany(entity.name).then((res) => res.items[0]);
-        return new Promise((resolve) => resolve(true));
-    }
-    // File uploader function
-    uploadFile(file, title, customUrl) {
-        const url = customUrl ? `${this.mainUrl}/${customUrl}` : `${this.mainUrl}/common/files`;
-        const formData = new FormData();
-        formData.append('File', file);
-        formData.append('Title', title);
-        return firstValueFrom(this.http.post(url, formData));
-    }
-    // Function to upload multiple files
-    uploadMultipleFiles(files, title) {
-        const uploadPromises = files.map((file) => this.uploadFile(file, title));
-        return Promise.all(uploadPromises);
-    }
-    // Function to view a file
-    viewFile(id, name) {
-        const url = `${this.mainUrl}/common/files/${id}/View/${name}`;
-        return firstValueFrom(this.http.get(url, { responseType: 'blob' }));
-    }
-    // Function to download a file
-    downloadFile(id, name) {
-        const url = `${this.mainUrl}/common/files/${id}/Download/${name}`;
-        return firstValueFrom(this.http.get(url, { responseType: 'blob' }));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMBackendDataProvider, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMBackendDataProvider, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMBackendDataProvider, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: i1.HttpClient }] });
-
 class AXMOidcApplicationLoader {
     constructor(http) {
         this.http = http;
@@ -193,10 +58,10 @@ class AXMOidcApplicationLoader {
             // features: item.features || [],
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMOidcApplicationLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMOidcApplicationLoader }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOidcApplicationLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOidcApplicationLoader }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMOidcApplicationLoader, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOidcApplicationLoader, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.HttpClient }] });
 
@@ -236,10 +101,10 @@ class AXMConfigurationService {
             switchMap(() => of(this.applicationConfig)));
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMConfigurationService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMConfigurationService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMConfigurationService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMConfigurationService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMConfigurationService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMConfigurationService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -266,146 +131,413 @@ class AXMOidcFeatureLoader {
     }
 }
 
-// Other imports...
-class AXMOidcUserManagerService {
-    constructor(authConfig) {
-        this.authConfig = authConfig;
-        this.selectedTenant = null;
-        this.selectedApplication = null;
-        if (!authConfig.oidc_settings) {
-            throw new Error('OIDC configuration is missing');
-        }
-        this.userManager = new UserManager({
-            ...authConfig.oidc_settings,
-            userStore: new WebStorageStateStore({ store: window.localStorage }),
-        });
-    }
-    getUserManager() {
-        return this.userManager;
-    }
-    async signinSilentCallback() {
-        await this.userManager.signinSilentCallback();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMOidcUserManagerService, deps: [{ token: AXM_AUTH_CONFIG_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMOidcUserManagerService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMOidcUserManagerService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [AXM_AUTH_CONFIG_TOKEN]
-                }] }] });
-
 class AXMOidcStrategy {
     constructor() {
-        this.injector = inject(Injector);
-        this.userManagerService = this.injector.get(AXMOidcUserManagerService);
-        this.userManager = this.userManagerService.getUserManager();
-        // Log.setLogger(console);
-        // Log.setLevel(Log.DEBUG);
-    }
-    get name() {
-        return 'user-pass';
+        this.aXMAuthConfigs = inject(AXM_AUTH_CONFIG_TOKEN);
+        this.oauthService = inject(OAuthService);
+        this.http = inject(HttpClient);
+    }
+    async configureOAuth() {
+        if (this.openidConfigurationInfo)
+            return;
+        if (!this.authConfig) {
+            if (!this.aXMAuthConfigs.authConfig) {
+                throw new Error('authConfig is missing');
+            }
+            this.authConfig = this.aXMAuthConfigs.authConfig;
+        }
+        this.oauthService.configure(this.authConfig);
+        this.oauthService.setStorage(localStorage);
+        this.openidConfigurationInfo = await this.oauthService.loadDiscoveryDocument();
+        if (!this.openidConfigurationInfo) {
+            throw new Error('openidConfigurationInfo is missing');
+        }
+        this.oauthService.events.subscribe(async (event) => {
+            // console.log('event', event);
+            // if (event.type === 'token_received') {
+            //   console.log('Token has been refreshed');
+            // }
+            // if (event.type === 'token_expires') {
+            //   console.log('Token is about to expire. Triggering silent refresh...');
+            // }
+        });
+        const oidcJson = localStorage.getItem(AXPSessionService.SESSION_KEY);
+        if (oidcJson) {
+            const authData = JSON.parse(oidcJson);
+            if (authData) {
+                this.setServiceProps(authData);
+                if (authData.expiresIn && new Date(authData.expiresIn) < new Date()) {
+                    if (authData.expiresIn) {
+                        // this.refresh();
+                    }
+                    else {
+                        this.logout();
+                    }
+                }
+            }
+        }
     }
     async signin(credentials) {
+        await this.configureOAuth();
         try {
-            await this.userManager.removeUser();
-            await this.userManager.clearStaleState();
-            const oidcUser = await this.userManager.signinSilent({
-                extraQueryParams: {
-                    username: credentials.username,
-                    password: credentials.password,
-                },
+            const body = new HttpParams()
+                .set('grant_type', 'password')
+                .set('client_id', this.authConfig.clientId)
+                .set('client_secret', this.authConfig.dummyClientSecret)
+                .set('username', credentials.username)
+                .set('password', credentials.password)
+                .set('scope', this.authConfig.scope);
+            const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
+            const response = await firstValueFrom(this.http.post(this.openidConfigurationInfo.info.discoveryDocument.token_endpoint, body.toString(), { headers }));
+            // const authData = new AuthenticationData(response);
+            this.setServiceProps({
+                accessToken: response.access_token,
+                refreshToken: response.refresh_token,
+                idToken: response.id_token,
+                expiresIn: this.calculateExpireInDate(response.expires_in ?? 0),
             });
-            if (oidcUser) {
-                const profile = oidcUser.profile; // Cast to any to access deeply nested properties
-                const user = {
-                    id: profile.sub,
-                    name: `${profile.email}`,
-                    title: `${profile.name}`,
-                    avatar: `${profile.picture}`,
-                };
-                const accessToken = oidcUser.access_token;
-                const refreshToken = oidcUser.refresh_token ?? '';
+            return {
+                succeed: true,
+                data: {
+                    accessToken: response.access_token,
+                    expiresIn: this.calculateExpireInDate(response.expires_in ?? 0),
+                    idToken: response.id_token,
+                    refreshToken: response.refresh_token,
+                    user: {
+                        id: response.sub,
+                        title: response.fullname,
+                        name: response.sub,
+                        avatar: response.picture,
+                    },
+                    tenant: {
+                        id: response.tenantid,
+                        name: response.tenantname,
+                        title: response.tenanttitle,
+                    },
+                    application: {
+                        id: response.applicationid,
+                        name: response.applicationname,
+                        title: response.applicationtitle,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    async signout() {
+        this.logout();
+    }
+    async refreshToken(context) {
+        console.log('context.tenant', context.tenant);
+        try {
+            await this.configureOAuth();
+            const refreshResult = await this.refresh(context.tenant?.id, context.application?.id);
+            if (refreshResult) {
                 return {
                     succeed: true,
-                    data: { user, accessToken, refreshToken },
+                    data: {
+                        accessToken: this.oauthService.getAccessToken(),
+                        refreshToken: this.oauthService.getRefreshToken(),
+                    },
                 };
             }
-            return {
-                succeed: false,
-            };
+            else {
+                return { succeed: false };
+            }
         }
         catch (error) {
-            if (error?.message)
-                throw new Error(error.message);
-            // Depending on the error type, you might want to throw a specific error
+            console.error('Error refreshing token', error);
+            return { succeed: false };
+        }
+    }
+    async refresh(tenantId, applicationId) {
+        await this.configureOAuth();
+        const authData = this.loadAuthData();
+        if (!authData)
+            return false;
+        const refreshToken = this.oauthService.getRefreshToken();
+        if (!refreshToken)
+            return false;
+        const body = new HttpParams()
+            .set('grant_type', 'refresh_token')
+            .set('client_id', this.authConfig.clientId)
+            .set('client_secret', this.authConfig.dummyClientSecret)
+            .set('refresh_token', refreshToken)
+            .set('tenantId', tenantId ?? '')
+            .set('applicationId', applicationId ?? '');
+        const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
+        try {
+            const response = await firstValueFrom(this.http.post(this.openidConfigurationInfo.info.discoveryDocument.token_endpoint, body.toString(), { headers }));
+            this.setServiceProps({
+                accessToken: response.access_token,
+                refreshToken: response.refresh_token,
+                idToken: response.id_token,
+                expiresIn: this.calculateExpireInDate(response.expires_in ?? 0),
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('Token refresh error', error);
+            return false;
+        }
+    }
+    expires_in_milisecound(expires_in_date) {
+        const now = new Date();
+        const expire = new Date(expires_in_date);
+        return expire.getTime() - now.getTime();
+    }
+    setServiceProps(authData) {
+        this.oauthService.getAccessToken = () => authData.accessToken;
+        this.oauthService.getIdToken = () => authData.idToken ?? '';
+        this.oauthService.getRefreshToken = () => authData.refreshToken;
+        if (authData.expiresIn) {
+            const refreshTime = this.expires_in_milisecound(authData.expiresIn);
+            this.oauthService.getAccessTokenExpiration = () => refreshTime;
+            // if (refreshTime < 0) {
+            //   this.refresh();
+            // }else{
+            // }
+        }
+    }
+    loadAuthData() {
+        const authDataJson = localStorage.getItem(AXPSessionService.SESSION_KEY);
+        if (!authDataJson)
+            return undefined;
+        const authData = JSON.parse(authDataJson);
+        // return authData ? new AuthenticationData(authData) : undefined;
+        return authData;
+    }
+    async loadUserInfo() {
+        return this.oauthService.loadUserProfile();
+    }
+    calculateExpireInDate(expireInMilisecound) {
+        return new Date(Date.now() + expireInMilisecound * 1000).toISOString();
+    }
+    logout() {
+        this.oauthService.logOut({
+            noRedirectToLogoutUrl: true
+        });
+    }
+    handleError(error) {
+        if (error?.reason) {
+            throw new Error(JSON.stringify(error.reason));
+        }
+        else if (error?.message) {
+            throw new Error(error.message);
+        }
+        else {
             throw new Error('Network or server error occurred');
         }
     }
-    async signout() {
-        console.log('User signed out');
-        this.userManager.removeUser();
-        this.userManager.clearStaleState();
-        //this.userManager.signoutSilent();
+    //#region getter
+    get name() {
+        return 'user-pass';
     }
-    async refreshToken(context) {
-        const currentUser = await this.userManager.getUser();
-        if (currentUser) {
-            const accessToken = currentUser?.access_token;
-            const newRefreshToken = currentUser?.refresh_token;
-            return {
-                succeed: true,
-                data: { accessToken, refreshToken: newRefreshToken },
-            };
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOidcStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOidcStrategy }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOidcStrategy, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMOidcPermissionLoader {
+    constructor(http) {
+        this.http = http;
+        this.configs = inject(AXP_ROOT_CONFIG_TOKEN);
+        this.apiGetConfig = `${this.configs.baseUrl}/abp/application-configuration`;
+    }
+    getList(context) {
+        return this.http.get(this.apiGetConfig).pipe(map((response) => this.mapTo(response)));
+        // if (context.user == null)
+        //   return of([]);
+        // else if (context.user.name.toLowerCase() == 'admin')
+        //   return of(['axp.admin.console', 'asc.admin.message', 'asc.admin.settings', 'asc.admin.gliding', 'asc.user.gliding']);
+        // else
+        //   return of(['asc.user.gliding']);
+        // return of(['axp.admin.console', 'asc.admin.message', 'asc.admin.settings', 'asc.admin.gliding', 'asc.user.gliding']);
+    }
+    mapTo(jsonObj) {
+        const policies = jsonObj.auth.grantedPolicies;
+        const truePolicies = Object.keys(policies).filter((key) => policies[key] === true);
+        return truePolicies;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOidcPermissionLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOidcPermissionLoader }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOidcPermissionLoader, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+
+class AXMOidcTenantLoader {
+    constructor(http) {
+        this.http = http;
+        this.configs = inject(AXP_ROOT_CONFIG_TOKEN);
+        this.apiGetTenants = `${this.configs.baseUrl}/user-tenants/Tenants`;
+        this.apiSetTenant = `${this.configs.baseUrl}/SetTenant`;
+    }
+    getList() {
+        return this.http.get(this.apiGetTenants).pipe(map((response) => response.items.map((item) => this.mapToAXPTenant(item))));
+    }
+    async set(tenant) {
+        return Promise.resolve();
+    }
+    mapToAXPTenant(item) {
+        return {
+            id: item.id,
+            name: item.name || 'defaultName',
+            title: item.title || 'defaultTitle',
+            // Add other fields and defaults as needed, and handle the logo if applicable
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOidcTenantLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOidcTenantLoader }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMOidcTenantLoader, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+
+class AXMBackendDataProvider {
+    constructor(http) {
+        this.http = http;
+        this.configs = inject(AXP_ROOT_CONFIG_TOKEN);
+        this.mainUrl = this.configs.baseUrl;
+    }
+    insertOne(entity, entityItem) {
+        const url = `${this.mainUrl}${entity.area ? '/' + entity.area : ''}/${entity.module}/${entity.name}`;
+        return firstValueFrom(this.http.post(url, entityItem));
+    }
+    insertMany(entity, entityList) {
+        const promises = entityList.map((entity) => {
+            const url = `${this.mainUrl}${entity.area ? '/' + entity.area : ''}/${entity.module}/${entity.name}`;
+            return firstValueFrom(this.http.post(url, entity));
+        });
+        return Promise.all(promises);
+    }
+    getOne(entity, id) {
+        const url = `${this.mainUrl}${entity.area ? '/' + entity.area : ''}/${entity.module}/${entity.name}${id ? '/' + id : ''}`;
+        return firstValueFrom(this.http.get(url));
+    }
+    getMany(entity, params) {
+        let httpParams = new HttpParams().set('Skip', params?.skip?.toString() ?? '0').set('Take', params?.take?.toString() ?? '10');
+        if (params?.sort && params?.sort.length > 0) {
+            const sortParam = params?.sort.map((sort) => `${sort.field}:${sort.dir}`).join(',');
+            httpParams = httpParams.set('$orderby', sortParam);
+        }
+        const buildFilterString = (filters) => {
+            return filters
+                .map((f) => {
+                if (f.filters) {
+                    return buildFilterString(f.filters);
+                }
+                else {
+                    return `${f.field} ${f.operator.type} ${f.value}`;
+                }
+            })
+                .join(',');
+        };
+        let filterString = params?.customFilter ? params.customFilter : '';
+        if (params?.filter) {
+            const filter = params.filter;
+            if (filter.filters) {
+                // Construct filter string from provided filters
+                const dynamicFilters = buildFilterString(filter.filters);
+                // Append dynamic filters to custom filter, if both exist
+                filterString = filterString ? `${filterString},${dynamicFilters}` : dynamicFilters;
+            }
+        }
+        // Set the $filter parameter if there are any filters
+        if (filterString) {
+            httpParams = httpParams.set('$filter', filterString);
+        }
+        function capitalizeFirstLetter(str) {
+            return str ? str.charAt(0).toUpperCase() + str.slice(1) : str;
+        }
+        function generateQueryString(filter) {
+            if (!filter.filters) {
+                // Base case: single filter
+                return `${capitalizeFirstLetter(filter.field)} ${filter.operator.type} ${filter.value}`;
+            }
+            else if (!filter.filters.length) {
+                return;
+            }
+            else {
+                // Recursive case: multiple filters
+                const filterStrings = filter.filters.map((subFilter) => generateQueryString(subFilter));
+                const logic = filter.logic || 'AND'; // Default logic is 'AND' if not provided
+                return `${filterStrings.filter((i) => i).join(` ${logic} `)}`;
+            }
+        }
+        let queryString = params?.customFilter ? params.customFilter : '';
+        if (params?.filter) {
+            const filter = params.filter;
+            if (filter.filters && filter.filters.length > 0) {
+                // Construct filter string from provided filters
+                const dynamicQueries = generateQueryString(filter);
+                console.log({ dynamicQueries: dynamicQueries });
+                // Append dynamic filters to custom filter, if both exist
+                queryString = queryString ? `${queryString},${dynamicQueries}` : dynamicQueries;
+            }
         }
-        else {
+        // Set the $filter parameter if there are any filters
+        if (queryString) {
+            httpParams = httpParams.set('$query', queryString);
+        }
+        return firstValueFrom(this.http.get(`${this.mainUrl}${entity.area ? '/' + entity.area : ''}/${entity.module}/${params?.costumGetter ? params.costumGetter : entity.name}/${params?.sub ? params.sub : ''}`, { params: httpParams })).then((response) => {
             return {
-                succeed: false,
+                total: response.totalCount,
+                items: response.items,
             };
-        }
+        });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMOidcStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMOidcStrategy }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMOidcStrategy, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
-class AXMOidcPermissionLoader {
-    constructor(http) {
-        this.http = http;
-        this.configs = inject(AXP_ROOT_CONFIG_TOKEN);
-        this.apiGetConfig = `${this.configs.baseUrl}/abp/application-configuration`;
+    updateOne(entity, id, data) {
+        const url = `${this.mainUrl}${entity.area ? '/' + entity.area : ''}/${entity.module}/${entity.name}${id ? '/' + id : ''}`;
+        return firstValueFrom(this.http.put(url, data));
     }
-    getList(context) {
-        return this.http.get(this.apiGetConfig).pipe(map((response) => this.mapTo(response)));
-        // if (context.user == null)
-        //   return of([]);
-        // else if (context.user.name.toLowerCase() == 'admin')
-        //   return of(['axp.admin.console', 'asc.admin.message', 'asc.admin.settings', 'asc.admin.gliding', 'asc.user.gliding']);
-        // else
-        //   return of(['asc.user.gliding']);
-        // return of(['axp.admin.console', 'asc.admin.message', 'asc.admin.settings', 'asc.admin.gliding', 'asc.user.gliding']);
+    deleteOne(entity, id) {
+        const url = `${this.mainUrl}${entity.area ? '/' + entity.area : ''}/${entity.module}/${entity.name}/${id}`;
+        return firstValueFrom(this.http.delete(url));
     }
-    mapTo(jsonObj) {
-        const policies = jsonObj.auth.grantedPolicies;
-        const truePolicies = Object.keys(policies).filter((key) => policies[key] === true);
-        return truePolicies;
+    getFirst(entity) {
+        // return this.getMany(entity.name).then((res) => res.items[0]);
+        return new Promise((resolve) => resolve(true));
+    }
+    // File uploader function
+    uploadFile(file, title, customUrl) {
+        const url = customUrl ? `${this.mainUrl}/${customUrl}` : `${this.mainUrl}/common/files`;
+        const formData = new FormData();
+        formData.append('File', file);
+        formData.append('Title', title);
+        return firstValueFrom(this.http.post(url, formData));
+    }
+    // Function to upload multiple files
+    uploadMultipleFiles(files, title) {
+        const uploadPromises = files.map((file) => this.uploadFile(file, title));
+        return Promise.all(uploadPromises);
+    }
+    // Function to view a file
+    viewFile(id, name) {
+        const url = `${this.mainUrl}/common/files/${id}/View/${name}`;
+        return firstValueFrom(this.http.get(url, { responseType: 'blob' }));
+    }
+    // Function to download a file
+    downloadFile(id, name) {
+        const url = `${this.mainUrl}/common/files/${id}/Download/${name}`;
+        return firstValueFrom(this.http.get(url, { responseType: 'blob' }));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMOidcPermissionLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMOidcPermissionLoader }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMBackendDataProvider, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMBackendDataProvider, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMOidcPermissionLoader, decorators: [{
-            type: Injectable
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMBackendDataProvider, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
         }], ctorParameters: () => [{ type: i1.HttpClient }] });
 
 class SignincallbackComponent {
-    constructor(userManagerService, router, route) {
-        this.userManagerService = userManagerService;
+    constructor(router, route) {
         this.router = router;
         this.route = route;
         this.sessionService = inject(AXPSessionService);
@@ -430,122 +562,110 @@ class SignincallbackComponent {
             };
             this.sessionService.setApplication(selectedApplication);
         }
-        this.userManagerService.signinSilentCallback();
+        // this.userManagerService.signinSilentCallback();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: SignincallbackComponent, deps: [{ token: AXMOidcUserManagerService }, { token: i2.Router }, { token: i2.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.2", type: SignincallbackComponent, selector: "ng-component", ngImport: i0, template: '', isInline: true }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: SignincallbackComponent, deps: [{ token: i1$1.Router }, { token: i1$1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.0", type: SignincallbackComponent, selector: "ng-component", ngImport: i0, template: '', isInline: true }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: SignincallbackComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: SignincallbackComponent, decorators: [{
             type: Component,
             args: [{
                     template: '',
                 }]
-        }], ctorParameters: () => [{ type: AXMOidcUserManagerService }, { type: i2.Router }, { type: i2.ActivatedRoute }] });
+        }], ctorParameters: () => [{ type: i1$1.Router }, { type: i1$1.ActivatedRoute }] });
 
-class AXMOidcTenantLoader {
-    constructor(http) {
-        this.http = http;
+class AXMFileManagementService {
+    constructor() {
         this.configs = inject(AXP_ROOT_CONFIG_TOKEN);
-        this.apiGetTenants = `${this.configs.baseUrl}/user-tenants/Tenants`;
-        this.apiSetTenant = `${this.configs.baseUrl}/SetTenant`;
+        this.mainUrl = this.configs.baseUrl;
+        this.http = inject(HttpClient);
+        this.networkService = inject(AXNetworkService);
+    }
+    upload(requests) {
+        const url = `${this.mainUrl}/common/files`;
+        const tasks = requests.map((r) => {
+            const formData = new FormData();
+            formData.append('File', r.file);
+            const task = this.networkService.upload(url, formData);
+            return new Promise((resolve, reject) => {
+                task.events.subscribe({
+                    next: (event) => {
+                        if (event.status == AXUploadStatus.UploadFailed) {
+                            r.error(event.message || '');
+                            reject(event.result);
+                        }
+                        if (event.status == AXUploadStatus.UploadComplete) {
+                            r.finish();
+                            resolve(event.result);
+                        }
+                        else {
+                            r.setTransferredBytes(event.bytesTransferred);
+                        }
+                    },
+                });
+                r.onStart.subscribe(() => {
+                    task.start();
+                });
+                r.onCancel.subscribe(() => {
+                    task.cancel();
+                    reject({ status: 'cancelled', request: r });
+                });
+                r.upload();
+            });
+        });
+        return Promise.allSettled(tasks);
     }
-    getList() {
-        return this.http.get(this.apiGetTenants).pipe(map((response) => response.items.map((item) => this.mapToAXPTenant(item))));
+    delete(fileId) {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => resolve({ success: true, fileId }), 1000);
+        });
     }
-    async set(tenant) {
-        return Promise.resolve();
+    get(fileId, name) {
+        return new Observable((observer) => {
+            const url = `${this.mainUrl}/common/files/${fileId}/Download/${name}`;
+            const downloadTask = this.networkService.download(url);
+            downloadTask.events.subscribe((event) => {
+                // Emit progress events
+                observer.next({
+                    status: event.status,
+                    progress: event.progress,
+                    fileId,
+                    data: event.data || null, // Assuming `event.data` contains the downloaded file's data when completed
+                });
+                // Complete the observable if download is finished
+                if (event.status === AXDownloadStatus.DownloadComplete) {
+                    observer.complete();
+                }
+            }, (error) => {
+                console.error('Download failed:', error);
+                observer.error({
+                    status: 'failed',
+                    fileId,
+                    error,
+                });
+            });
+            return () => {
+                downloadTask.cancel();
+            };
+        });
     }
-    mapToAXPTenant(item) {
-        return {
-            id: item.id,
-            name: item.name || 'defaultName',
-            title: item.title || 'defaultTitle',
-            // Add other fields and defaults as needed, and handle the logo if applicable
-        };
+    list() {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => resolve([{ fileId: '1', data: 'fileData' }]), 1000);
+        });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMOidcTenantLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMOidcTenantLoader }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMOidcTenantLoader, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.HttpClient }] });
-
-function routesFactory() {
-    const routes = [{ path: 'auth/signincallback', component: SignincallbackComponent }];
-    return routes;
-}
-class AXMBackendModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMBackendModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.2", ngImport: i0, type: AXMBackendModule, imports: [i1$1.AXMAuthModule, i2$1.AXPAuthModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMBackendModule, providers: [
-            {
-                provide: AXPDataProvider,
-                useClass: AXMBackendDataProvider,
-            },
-            {
-                provide: AXP_TENANT_LOADER,
-                useClass: AXMOidcTenantLoader,
-            },
-            {
-                provide: AXP_APPLICATION_LOADER,
-                useClass: AXMOidcApplicationLoader,
-            },
-            {
-                provide: AXP_PERMISSION_LOADER,
-                useClass: AXMOidcPermissionLoader,
-            },
-            {
-                provide: AXP_FEATURE_LOADER,
-                useClass: AXMOidcFeatureLoader,
-            },
-            {
-                provide: ROUTES,
-                multi: true,
-                useFactory: routesFactory,
-            },
-        ], imports: [AXMAuthModule.forRoot(),
-            AXPAuthModule.forRoot({
-                strategies: [AXMOidcStrategy],
-            })] }); }
+    setMetadata(fileId, metadata) {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => resolve({ fileId, metadata }), 1000);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFileManagementService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFileManagementService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMBackendModule, decorators: [{
-            type: NgModule,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMFileManagementService, decorators: [{
+            type: Injectable,
             args: [{
-                    imports: [
-                        AXMAuthModule.forRoot(),
-                        AXPAuthModule.forRoot({
-                            strategies: [AXMOidcStrategy],
-                        }),
-                    ],
-                    exports: [],
-                    declarations: [],
-                    providers: [
-                        {
-                            provide: AXPDataProvider,
-                            useClass: AXMBackendDataProvider,
-                        },
-                        {
-                            provide: AXP_TENANT_LOADER,
-                            useClass: AXMOidcTenantLoader,
-                        },
-                        {
-                            provide: AXP_APPLICATION_LOADER,
-                            useClass: AXMOidcApplicationLoader,
-                        },
-                        {
-                            provide: AXP_PERMISSION_LOADER,
-                            useClass: AXMOidcPermissionLoader,
-                        },
-                        {
-                            provide: AXP_FEATURE_LOADER,
-                            useClass: AXMOidcFeatureLoader,
-                        },
-                        {
-                            provide: ROUTES,
-                            multi: true,
-                            useFactory: routesFactory,
-                        },
-                    ],
+                    providedIn: 'root',
                 }]
         }] });
 
@@ -755,19 +875,108 @@ class AXMLocalDataProvider {
     downloadFile(id, name) {
         return this.viewFile(id, name);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMLocalDataProvider, deps: [{ token: i1$2.AXPStorageMockService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMLocalDataProvider, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLocalDataProvider, deps: [{ token: i1$2.AXPStorageMockService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLocalDataProvider, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXMLocalDataProvider, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLocalDataProvider, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [{ type: i1$2.AXPStorageMockService }] });
 
+function routesFactory() {
+    const routes = [{ path: 'auth/signincallback', component: SignincallbackComponent }];
+    return routes;
+}
+class AXMBackendModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMBackendModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXMBackendModule, imports: [i1$3.OAuthModule, i2.AXMAuthModule, i3.AXPAuthModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMBackendModule, providers: [
+            {
+                provide: AXPDataProvider,
+                useClass: AXMBackendDataProvider,
+            },
+            {
+                provide: AXP_TENANT_LOADER,
+                useClass: AXMOidcTenantLoader,
+            },
+            {
+                provide: AXP_APPLICATION_LOADER,
+                useClass: AXMOidcApplicationLoader,
+            },
+            {
+                provide: AXP_PERMISSION_LOADER,
+                useClass: AXMOidcPermissionLoader,
+            },
+            {
+                provide: AXP_FEATURE_LOADER,
+                useClass: AXMOidcFeatureLoader,
+            },
+            {
+                provide: AXPFileManagementService,
+                useClass: AXMFileManagementService,
+            },
+            {
+                provide: ROUTES,
+                multi: true,
+                useFactory: routesFactory,
+            },
+        ], imports: [OAuthModule.forRoot(),
+            AXMAuthModule.forRoot(),
+            AXPAuthModule.forRoot({
+                strategies: [AXMOidcStrategy],
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMBackendModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        OAuthModule.forRoot(),
+                        AXMAuthModule.forRoot(),
+                        AXPAuthModule.forRoot({
+                            strategies: [AXMOidcStrategy],
+                        }),
+                    ],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXPDataProvider,
+                            useClass: AXMBackendDataProvider,
+                        },
+                        {
+                            provide: AXP_TENANT_LOADER,
+                            useClass: AXMOidcTenantLoader,
+                        },
+                        {
+                            provide: AXP_APPLICATION_LOADER,
+                            useClass: AXMOidcApplicationLoader,
+                        },
+                        {
+                            provide: AXP_PERMISSION_LOADER,
+                            useClass: AXMOidcPermissionLoader,
+                        },
+                        {
+                            provide: AXP_FEATURE_LOADER,
+                            useClass: AXMOidcFeatureLoader,
+                        },
+                        {
+                            provide: AXPFileManagementService,
+                            useClass: AXMFileManagementService,
+                        },
+                        {
+                            provide: ROUTES,
+                            multi: true,
+                            useFactory: routesFactory,
+                        },
+                    ],
+                }]
+        }] });
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXMBackendDataProvider, AXMBackendModule, AXMConfigurationService, AXMLocalDataProvider, AXMOidcApplicationLoader, AXMOidcFeatureLoader, AXMOidcPermissionLoader, AXMOidcStrategy, AXMOidcTenantLoader, AXMOidcUserManagerService, SignincallbackComponent, applyFilterArray, applySortArray };
+export { AXMBackendDataProvider, AXMBackendModule, AXMConfigurationService, AXMFileManagementService, AXMLocalDataProvider, AXMOidcApplicationLoader, AXMOidcFeatureLoader, AXMOidcPermissionLoader, AXMOidcStrategy, AXMOidcTenantLoader, applyFilterArray, applySortArray };
 //# sourceMappingURL=acorex-modules-backend.mjs.map