@acorex/modules 19.1.6 → 19.1.7

package/fesm2022/acorex-modules-backend.mjs

@@ -1,943 +0,0 @@
-import { AXM_AUTH_CONFIG_TOKEN, AXMAuthModule } from '@acorex/modules/auth';
-import * as i2 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, AXPFilterOperatorMiddlewareService, AXPDataProvider } from '@acorex/platform/common';
-import * as i0 from '@angular/core';
-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 { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';
-import { map, BehaviorSubject, tap, filter, take, of, switchMap, delay, firstValueFrom, Observable } from 'rxjs';
-import * as i1$2 from 'angular-oauth2-oidc';
-import { OAuthService, OAuthModule } from 'angular-oauth2-oidc';
-import { AXPModuleDesignerService } from '@acorex/modules/application-management';
-import { AXPFileManagementService } from '@acorex/platform/widgets';
-import { AXNetworkService, AXUploadStatus, AXDownloadStatus } from '@acorex/core/network';
-import { AXPEntityDefinitionRegistryService } from '@acorex/platform/layout/entity';
-
-class AXMOidcApplicationLoader {
-    constructor(http) {
-        this.http = http;
-        this.configs = inject(AXP_ROOT_CONFIG_TOKEN);
-        this.apiGetApps = `${this.configs.baseUrl}/applications/GetListByTenantId`;
-        this.apiSetApp = `${this.configs.baseUrl}/SetApplication`;
-    }
-    getList() {
-        return this.http.get(this.apiGetApps).pipe(map((response) => {
-            return response.items.map((item) => this.mapToAXPApplication(item));
-        }));
-    }
-    set(application) {
-        return Promise.resolve();
-    }
-    // //TODO: shoud be removed
-    // set(application: AXPApplication): Observable<AXPRefreshTokenResult> {
-    //   return this.http.post<any>(this.apiSetApp, { applicationId: application.id }).pipe(
-    //     map((response) => {
-    //       return {
-    //         succeed: true,
-    //         data: {
-    //           accessToken: response.token,
-    //           refreshToken: response.token,
-    //         }
-    //       };
-    //     })
-    //   );
-    // }
-    mapToAXPApplication(item) {
-        return {
-            id: item.id,
-            name: item.name || 'defaultName',
-            title: item.title || 'defaultTitle',
-            version: item.version || '1.0.0',
-            description: item.description,
-            logo: item.logo, // Assuming logo is of type AXPLogoConfig or undefined
-            editionName: item.editionName,
-            // features: item.features || [],
-        };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMOidcApplicationLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMOidcApplicationLoader }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMOidcApplicationLoader, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.HttpClient }] });
-
-class AXMConfigurationService {
-    constructor(http) {
-        this.http = http;
-        this.configs = inject(AXP_ROOT_CONFIG_TOKEN);
-        this.applicationConfig = null;
-        this.apiGetConfig = `${this.configs.baseUrl}/abp/application-configuration`;
-        this.fetchInProgress = false;
-        this.configSubject = new BehaviorSubject(null);
-        this.init().subscribe(); // Automatically trigger configuration load on service instantiation
-    }
-    init() {
-        if (!this.fetchInProgress) {
-            this.fetchInProgress = true;
-            return this.http.get(this.apiGetConfig).pipe(tap((response) => {
-                this.applicationConfig = response;
-                this.configSubject.next(this.applicationConfig);
-                this.fetchInProgress = false;
-            }));
-        }
-        else {
-            // Adjusted approach to handle TypeScript's type safety requirements
-            return this.configSubject.asObservable().pipe(filter((config) => config !== null), take(1) // Ensures it completes after emitting the first non-null value
-            );
-        }
-    }
-    getConfig() {
-        if (this.applicationConfig) {
-            // If the config is already loaded, return it immediately
-            return of(this.applicationConfig);
-        }
-        else {
-            // If the config is not loaded, initiate loading
-            return this.configSubject.asObservable().pipe(filter((config) => config !== null), take(1), // Ensure it only emits the first non-null value and completes
-            switchMap(() => of(this.applicationConfig)));
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMConfigurationService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMConfigurationService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMConfigurationService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: i1.HttpClient }] });
-
-class AXMOidcFeatureLoader {
-    constructor() {
-        this.list = [
-            {
-                name: 'axp-entity-list-custom-view',
-                title: 'Custom View',
-                value: false
-            },
-            {
-                name: 'axp-entity-list-quick-search',
-                title: 'Custom View',
-                value: false
-            }
-        ];
-    }
-    getList() {
-        return of(this.list).pipe(delay(0));
-    }
-}
-
-class AXMOidcStrategy {
-    constructor() {
-        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 {
-            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),
-            });
-            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) {
-        try {
-            await this.configureOAuth();
-            const refreshResult = await this.refresh(context.tenant?.id, context.application?.id);
-            if (refreshResult) {
-                return {
-                    succeed: true,
-                    data: {
-                        accessToken: this.oauthService.getAccessToken(),
-                        refreshToken: this.oauthService.getRefreshToken(),
-                    },
-                };
-            }
-            else {
-                return { succeed: false };
-            }
-        }
-        catch (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');
-        }
-    }
-    //#region getter
-    get name() {
-        return 'user-pass';
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMOidcStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMOidcStrategy }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", 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: "19.0.3", ngImport: i0, type: AXMOidcPermissionLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMOidcPermissionLoader }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", 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: "19.0.3", ngImport: i0, type: AXMOidcTenantLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMOidcTenantLoader }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", 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.filterService = inject(AXPFilterOperatorMiddlewareService);
-        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;
-        }
-        const greaterThanOperator = this.filterService.getOperator('greaterThan');
-        const lessThanOperator = this.filterService.getOperator('lessThan');
-        function generateQueryString(filter) {
-            if (!filter.filters) {
-                // Base case: single filter
-                if (typeof filter.value === 'object' && filter.operator.type === 'between') {
-                    return `${filter.field} ${greaterThanOperator.type} '${filter.value.from}' and ${filter.field} ${lessThanOperator.type} '${filter.value.to}'`;
-                }
-                else {
-                    return `${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} `)}`;
-            }
-        }
-        if (params?.date) {
-            httpParams = httpParams.set('Date', params.date);
-        }
-        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));
-    }
-    // to update a uploaded file
-    updateFile(id, file, title, customUrl) {
-        const url = customUrl ? `${this.mainUrl}/${customUrl}` : `${this.mainUrl}/common/files?id=${id}`;
-        const formData = new FormData();
-        formData.append('File', file);
-        formData.append('Title', title);
-        return firstValueFrom(this.http.put(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: "19.0.3", ngImport: i0, type: AXMBackendDataProvider, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMBackendDataProvider, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMBackendDataProvider, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: i1.HttpClient }] });
-
-class SignincallbackComponent {
-    constructor(router, route) {
-        this.router = router;
-        this.route = route;
-        this.sessionService = inject(AXPSessionService);
-    }
-    ngOnInit() {
-        const queryParams = this.route.snapshot.queryParams;
-        if (queryParams['tenantid']) {
-            const selectedTenant = {
-                id: queryParams['tenantid'],
-                name: queryParams['tenantname'],
-                title: queryParams['tenanttitle'],
-            };
-            this.sessionService.setTenant(selectedTenant);
-        }
-        if (queryParams['applicationid']) {
-            const selectedApplication = {
-                id: queryParams['applicationid'],
-                name: queryParams['applicationname'],
-                title: queryParams['applicationtitle'],
-                version: '1',
-                editionName: queryParams['editionname'],
-            };
-            this.sessionService.setApplication(selectedApplication);
-        }
-        // this.userManagerService.signinSilentCallback();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", 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: "19.0.3", type: SignincallbackComponent, isStandalone: false, selector: "ng-component", ngImport: i0, template: '', isInline: true }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: SignincallbackComponent, decorators: [{
-            type: Component,
-            args: [{
-                    template: '',
-                    standalone: false
-                }]
-        }], ctorParameters: () => [{ type: i1$1.Router }, { type: i1$1.ActivatedRoute }] });
-
-class AXMCommentService {
-    constructor() {
-        this.configs = inject(AXP_ROOT_CONFIG_TOKEN);
-        this.http = inject(HttpClient);
-        this.mainUrl = this.configs.baseUrl;
-        this.messagesUrl = `${this.configs.baseUrl}/conversion/messages/room`;
-        this.messagePostUrl = `${this.configs.baseUrl}/conversion/messages`;
-        this.messageReactionUrl = `${this.configs.baseUrl}/conversion/message-reactions/change`;
-    }
-    async get(params) {
-        const url = `${this.messagesUrl}`;
-        return await firstValueFrom(this.http.get(url, {
-            params: params,
-        }));
-    }
-    async post(payload) {
-        const url = `${this.messagePostUrl}`;
-        return await firstValueFrom(this.http.post(url, payload));
-    }
-    async put(payload) {
-        const url = `${this.messagePostUrl}/${payload.id}`;
-        return await firstValueFrom(this.http.put(url, { content: payload.content }));
-    }
-    async delete(payload) {
-        const url = `${this.messagePostUrl}/${payload.id}`;
-        return await firstValueFrom(this.http.delete(url));
-    }
-    async like(payload) {
-        const url = `${this.messageReactionUrl}`;
-        return await firstValueFrom(this.http.put(url, payload));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMCommentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMCommentService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMCommentService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-class AXMFileManagementService {
-    constructor() {
-        this.configs = inject(AXP_ROOT_CONFIG_TOKEN);
-        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);
-    }
-    delete(fileId) {
-        return new Promise((resolve, reject) => {
-            setTimeout(() => resolve({ success: true, fileId }), 1000);
-        });
-    }
-    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();
-            };
-        });
-    }
-    list() {
-        return new Promise((resolve, reject) => {
-            setTimeout(() => resolve([{ fileId: '1', data: 'fileData' }]), 1000);
-        });
-    }
-    setMetadata(fileId, metadata) {
-        return new Promise((resolve, reject) => {
-            setTimeout(() => resolve({ fileId, metadata }), 1000);
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFileManagementService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFileManagementService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMFileManagementService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-class AXMModuleDesignerService {
-    constructor() {
-        this.loader = inject(AXPEntityDefinitionRegistryService);
-        this.defaultConfig = {
-            skip: 0,
-            sort: [],
-            take: 10,
-            filter: {
-                field: '',
-                value: '',
-                operator: 'equal',
-            },
-        };
-        this.AdvanceConfig = (moduleId) => ({
-            skip: 0,
-            sort: [],
-            take: 10,
-            filter: {
-                field: '',
-                value: '',
-                operator: { type: 'equal' },
-                filters: [
-                    {
-                        field: 'moduleId',
-                        operator: { type: 'equal' },
-                        value: moduleId,
-                    },
-                ],
-            },
-        });
-    }
-    async moduleDef() {
-        return this.loader.resolve('application-management', 'module');
-    }
-    async entityDef() {
-        return this.loader.resolve('application-management', 'entity');
-    }
-    async featureDef() {
-        return this.loader.resolve('application-management', 'feature');
-    }
-    async permissionDef() {
-        return this.loader.resolve('application-management', 'permission');
-    }
-    async getModules() {
-        const entity = await this.moduleDef();
-        const func = entity?.queries.list?.execute;
-        return func(this.defaultConfig);
-    }
-    async getSingleModule() { }
-    async createModule(payload) { }
-    async updateModule(moduleId, payload) { }
-    async deleteModule(moduleId) { }
-    //
-    async getEntities(moduleId) {
-        const entity = await this.entityDef();
-        const func = entity?.queries.list?.execute;
-        return func(this.AdvanceConfig(moduleId));
-    }
-    async getSingleEntity(entityId) { }
-    async createEntity(payload) { }
-    async updateEntity(payload) { }
-    async deleteEntity(entityId) { }
-    //
-    async getFeatures(moduleId) {
-        const entity = await this.featureDef();
-        const func = entity?.queries.list?.execute;
-        return func(this.AdvanceConfig(moduleId));
-    }
-    async getSingleFeature(featureId) { }
-    async createFeature(payload) { }
-    async updateFeature(payload) { }
-    async deleteFeature(featureId) { }
-    //
-    async getPermissions(moduleId) {
-        const entity = await this.permissionDef();
-        const func = entity?.queries.list?.execute;
-        return func(this.AdvanceConfig(moduleId));
-    }
-    async getSinglePermission(permissionId) { }
-    async createPermission(payload) { }
-    async updatePermission(payload) { }
-    async deletePermission(permissionId) { }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMModuleDesignerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMModuleDesignerService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMModuleDesignerService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }] });
-
-function routesFactory() {
-    const routes = [{ path: 'auth/signincallback', component: SignincallbackComponent }];
-    return routes;
-}
-class AXMBackendModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMBackendModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: AXMBackendModule, imports: [i1$2.OAuthModule, AXMAuthModule, i2.AXPAuthModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", 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: AXPCommentService,
-            //   useClass: AXMCommentService,
-            // },
-            // {
-            //   provide: AXMNotificationService,
-            //   useClass: AXMMockNotificationService,
-            // },
-            {
-                provide: AXPModuleDesignerService,
-                useClass: AXMModuleDesignerService,
-            },
-            {
-                provide: ROUTES,
-                multi: true,
-                useFactory: routesFactory,
-            },
-        ], imports: [OAuthModule.forRoot(),
-            AXMAuthModule,
-            AXPAuthModule.forRoot({
-                strategies: [AXMOidcStrategy],
-            })] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AXMBackendModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        OAuthModule.forRoot(),
-                        AXMAuthModule,
-                        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: AXPCommentService,
-                        //   useClass: AXMCommentService,
-                        // },
-                        // {
-                        //   provide: AXMNotificationService,
-                        //   useClass: AXMMockNotificationService,
-                        // },
-                        {
-                            provide: AXPModuleDesignerService,
-                            useClass: AXMModuleDesignerService,
-                        },
-                        {
-                            provide: ROUTES,
-                            multi: true,
-                            useFactory: routesFactory,
-                        },
-                    ],
-                }]
-        }] });
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { AXMBackendDataProvider, AXMBackendModule, AXMCommentService, AXMConfigurationService, AXMFileManagementService, AXMModuleDesignerService, AXMOidcApplicationLoader, AXMOidcFeatureLoader, AXMOidcPermissionLoader, AXMOidcStrategy, AXMOidcTenantLoader };
-//# sourceMappingURL=acorex-modules-backend.mjs.map