@acorex/connectivity 20.2.0-next.0 → 20.2.0-next.2

package/fesm2022/acorex-connectivity-api.mjs

@@ -1,19 +1,20 @@
-import { AXP_ROOT_CONFIG_TOKEN, AXPFilterOperatorMiddlewareService, AXPFileStorageService, AXPFileStorageStatus, AXPRegionalService } from '@acorex/platform/common';
+import { AXP_ROOT_CONFIG_TOKEN, AXPFilterOperatorMiddlewareService, AXPRegionalService, AXPFileStorageService, AXPFileStorageStatus } from '@acorex/platform/common';
 import { AXPEntityResolver, AXPEntityStorageService } from '@acorex/platform/layout/entity';
 import * as i1 from '@angular/common/http';
 import { HttpParams, HttpClient, HttpHeaders } from '@angular/common/http';
 import * as i0 from '@angular/core';
 import { inject, Injectable, NgModule } from '@angular/core';
 import { kebabCase } from 'lodash-es';
-import { firstValueFrom, map, BehaviorSubject, tap, filter, take, of, switchMap, delay, catchError } from 'rxjs';
+import { firstValueFrom, catchError, of, map, BehaviorSubject, tap, filter, take, switchMap, delay } from 'rxjs';
 import * as i2 from '@acorex/platform/auth';
-import { AXPSessionService, AXPAuthModule, AXP_APPLICATION_LOADER, AXP_PERMISSION_LOADER, AXP_FEATURE_LOADER } from '@acorex/platform/auth';
+import { AXPAuthStrategy, AXPSessionService, JwtUtil, TimeUtil, PkceUtil, AXPAuthModule, AXP_TENANT_LOADER, AXP_APPLICATION_LOADER, AXP_PERMISSION_LOADER, AXP_FEATURE_LOADER } from '@acorex/platform/auth';
 import { STRATEGY_CONFIG_TOKEN } from '@acorex/platform/widgets';
 import * as i1$1 from 'angular-oauth2-oidc';
 import { OAuthService, OAuthModule } from 'angular-oauth2-oidc';
-import { AXM_AUTH_CONFIG_TOKEN } from '@acorex/modules/auth';
 import { AXUSLocaleProfile, AXIRLocaleProfile } from '@acorex/core/locale';
 import { AXTranslationService } from '@acorex/core/translation';
+import { AXM_AUTH_CONFIG_TOKEN } from '@acorex/modules/auth';
+import { Router } from '@angular/router';
 
 class AXCApiEntityStorageService {
     constructor(http) {
@@ -138,386 +139,252 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
             type: Injectable
         }], ctorParameters: () => [{ type: i1.HttpClient }] });
 
-class AXMOidcApplicationLoader {
-    constructor(http) {
-        this.http = http;
-        this.configs = inject(AXP_ROOT_CONFIG_TOKEN);
-        this.apiGetApps = `${this.configs.baseUrl}/applications/applications-for-current-tenant`;
-        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: "20.1.3", ngImport: i0, type: AXMOidcApplicationLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcApplicationLoader }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.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: "20.1.3", ngImport: i0, type: AXMConfigurationService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMConfigurationService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMConfigurationService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: i1.HttpClient }] });
-
-class AXMOidcFeatureLoader {
+class AXCRegionalApiService extends AXPRegionalService {
     constructor() {
-        this.list = [
+        super(...arguments);
+        this.http = inject(HttpClient);
+        this.languageService = inject(AXTranslationService);
+        //#region ----   API Endpoints   ----
+        this.baseUrl = '/api/regional';
+        //#endregion
+        //#region ----   Fallback Data   ----
+        this.fallbackCountries = [
             {
-                name: 'axp-entity-list-custom-view',
-                title: 'Custom View',
-                value: false
+                code: 'US',
+                title: 'United States',
+                native: 'United States',
+                regional: 'en',
+                timezone: 'America/New_York'
             },
             {
-                name: 'axp-entity-list-quick-search',
-                title: 'Custom View',
-                value: false
+                code: 'CA',
+                title: 'Canada',
+                native: 'Canada',
+                regional: 'en',
+                timezone: 'America/Toronto'
+            },
+            {
+                code: 'GB',
+                title: 'United Kingdom',
+                native: 'United Kingdom',
+                regional: 'en',
+                timezone: 'Europe/London'
             }
         ];
-    }
-    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(),
-                    },
-                };
+        this.fallbackProvinces = [
+            {
+                code: 'CA',
+                title: 'California',
+                native: 'California',
+                timezone: 'America/Los_Angeles'
+            },
+            {
+                code: 'NY',
+                title: 'New York',
+                native: 'New York',
+                timezone: 'America/New_York'
+            },
+            {
+                code: 'ON',
+                title: 'Ontario',
+                native: 'Ontario',
+                timezone: 'America/Toronto'
             }
-            else {
-                return { succeed: false };
+        ];
+        this.fallbackCities = [
+            {
+                code: 'NYC',
+                title: 'New York City',
+                native: 'New York City',
+                timezone: 'America/New_York'
+            },
+            {
+                code: 'LA',
+                title: 'Los Angeles',
+                native: 'Los Angeles',
+                timezone: 'America/Los_Angeles'
+            },
+            {
+                code: 'TOR',
+                title: 'Toronto',
+                native: 'Toronto',
+                timezone: 'America/Toronto'
             }
-        }
-        catch (error) {
-            console.error('Error refreshing token', error);
-            return { succeed: false };
-        }
+        ];
+        this.fallbackCurrencies = [
+            {
+                code: 'USD',
+                title: 'United States Dollar',
+                symbol: '$',
+                format: '${amount}'
+            },
+            {
+                code: 'CAD',
+                title: 'Canadian Dollar',
+                symbol: 'CA$',
+                format: 'CA${amount}'
+            },
+            {
+                code: 'GBP',
+                title: 'British Pound',
+                symbol: '£',
+                format: '£{amount}'
+            }
+        ];
+        this.fallbackLocaleProfiles = [
+            {
+                ...AXUSLocaleProfile,
+                code: 'en-US',
+                title: 'English (United States)',
+                nativeTitle: 'English (United States)',
+            },
+            {
+                ...AXIRLocaleProfile,
+                code: 'fa-IR',
+                title: 'Persian (Iran)',
+                nativeTitle: 'فارسی (ایران)',
+            }
+        ];
+        this.fallbackLanguages = [
+            {
+                code: 'en',
+                title: 'English'
+            },
+            {
+                code: 'fa',
+                title: 'Persian'
+            },
+            {
+                code: 'es',
+                title: 'Spanish'
+            }
+        ];
+        this.fallbackTimeZones = [
+            {
+                code: 'America/New_York',
+                title: 'Eastern Time (US & Canada)',
+                offset: '-05:00',
+                iana: 'America/New_York',
+                abbr: 'EST'
+            },
+            {
+                code: 'America/Los_Angeles',
+                title: 'Pacific Time (US & Canada)',
+                offset: '-08:00',
+                iana: 'America/Los_Angeles',
+                abbr: 'PST'
+            },
+            {
+                code: 'Europe/London',
+                title: 'Greenwich Mean Time',
+                offset: '+00:00',
+                iana: 'Europe/London',
+                abbr: 'GMT'
+            }
+        ];
     }
-    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');
+    //#endregion
+    async getCountries() {
+        const lang = await firstValueFrom(this.languageService.langChanges$);
         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),
+            const countries = await firstValueFrom(this.http.get(`${this.baseUrl}/countries`).pipe(catchError(() => of(this.fallbackCountries))));
+            return countries.map((country) => {
+                if (lang == country.regional) {
+                    return {
+                        ...country,
+                        title: country.native,
+                    };
+                }
+                else {
+                    return country;
+                }
             });
-            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{
-            // }
+        catch {
+            return this.fallbackCountries.map((country) => {
+                if (lang == country.regional) {
+                    return {
+                        ...country,
+                        title: country.native,
+                    };
+                }
+                else {
+                    return country;
+                }
+            });
         }
     }
-    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));
+    async getProvinces(countryId) {
+        let params = new HttpParams();
+        if (countryId) {
+            params = params.set('countryId', countryId);
         }
-        else if (error?.message) {
-            throw new Error(error.message);
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/provinces`, { params }).pipe(catchError(() => of(this.fallbackProvinces))));
         }
-        else {
-            throw new Error('Network or server error occurred');
+        catch {
+            return this.fallbackProvinces;
         }
     }
-    //#region getter
-    get name() {
-        return 'user-pass';
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcStrategy }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.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`;
+    async getCities(filter) {
+        let params = new HttpParams();
+        if (filter?.countryId) {
+            params = params.set('countryId', filter.countryId);
+        }
+        if (filter?.provinceId) {
+            params = params.set('provinceId', filter.provinceId);
+        }
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/cities`, { params }).pipe(catchError(() => of(this.fallbackCities))));
+        }
+        catch {
+            return this.fallbackCities;
+        }
     }
-    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']);
+    async getCurrencies() {
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/currencies`).pipe(catchError(() => of(this.fallbackCurrencies))));
+        }
+        catch {
+            return this.fallbackCurrencies;
+        }
     }
-    mapTo(jsonObj) {
-        const policies = jsonObj.auth.grantedPolicies;
-        const truePolicies = Object.keys(policies).filter((key) => policies[key] === true);
-        return truePolicies;
+    async getLocaleProfiles() {
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/locale-profiles`).pipe(catchError(() => of(this.fallbackLocaleProfiles))));
+        }
+        catch {
+            return this.fallbackLocaleProfiles;
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcPermissionLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcPermissionLoader }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.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}/tenants/available-for-user`;
+    async getLanguages() {
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/languages`).pipe(catchError(() => of(this.fallbackLanguages))));
+        }
+        catch {
+            return this.fallbackLanguages;
+        }
     }
-    getList() {
-        return this.http.get(this.apiGetTenants).pipe(map((response) => response.items.map((item) => {
-            return this.mapToAXPTenant(item);
-        })));
+    async getAvailableLanguages() {
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/available-languages`).pipe(catchError(() => of(this.fallbackLanguages))));
+        }
+        catch {
+            return this.fallbackLanguages;
+        }
     }
-    async set(tenant) {
-        return Promise.resolve();
+    async getBrowserTimeZoneCode() {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone;
     }
-    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
-        };
+    async getTimeZones() {
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/timezones`).pipe(catchError(() => of(this.fallbackTimeZones))));
+        }
+        catch {
+            return this.fallbackTimeZones;
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcTenantLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcTenantLoader }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcTenantLoader, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.HttpClient }] });
 
 class AXCFileStorageApiService extends AXPFileStorageService {
     constructor() {
@@ -658,252 +525,493 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
             type: Injectable
         }] });
 
-class AXCRegionalApiService extends AXPRegionalService {
-    constructor() {
-        super(...arguments);
-        this.http = inject(HttpClient);
-        this.languageService = inject(AXTranslationService);
-        //#region ----   API Endpoints   ----
-        this.baseUrl = '/api/regional';
-        //#endregion
-        //#region ----   Fallback Data   ----
-        this.fallbackCountries = [
-            {
-                code: 'US',
-                title: 'United States',
-                native: 'United States',
-                regional: 'en',
-                timezone: 'America/New_York'
-            },
-            {
-                code: 'CA',
-                title: 'Canada',
-                native: 'Canada',
-                regional: 'en',
-                timezone: 'America/Toronto'
-            },
-            {
-                code: 'GB',
-                title: 'United Kingdom',
-                native: 'United Kingdom',
-                regional: 'en',
-                timezone: 'Europe/London'
-            }
-        ];
-        this.fallbackProvinces = [
-            {
-                code: 'CA',
-                title: 'California',
-                native: 'California',
-                timezone: 'America/Los_Angeles'
-            },
-            {
-                code: 'NY',
-                title: 'New York',
-                native: 'New York',
-                timezone: 'America/New_York'
-            },
-            {
-                code: 'ON',
-                title: 'Ontario',
-                native: 'Ontario',
-                timezone: 'America/Toronto'
-            }
-        ];
-        this.fallbackCities = [
-            {
-                code: 'NYC',
-                title: 'New York City',
-                native: 'New York City',
-                timezone: 'America/New_York'
-            },
-            {
-                code: 'LA',
-                title: 'Los Angeles',
-                native: 'Los Angeles',
-                timezone: 'America/Los_Angeles'
-            },
-            {
-                code: 'TOR',
-                title: 'Toronto',
-                native: 'Toronto',
-                timezone: 'America/Toronto'
-            }
-        ];
-        this.fallbackCurrencies = [
-            {
-                code: 'USD',
-                title: 'United States Dollar',
-                symbol: '$',
-                format: '${amount}'
-            },
-            {
-                code: 'CAD',
-                title: 'Canadian Dollar',
-                symbol: 'CA$',
-                format: 'CA${amount}'
-            },
-            {
-                code: 'GBP',
-                title: 'British Pound',
-                symbol: '£',
-                format: '£{amount}'
-            }
-        ];
-        this.fallbackLocaleProfiles = [
-            {
-                ...AXUSLocaleProfile,
-                code: 'en-US',
-                title: 'English (United States)',
-                nativeTitle: 'English (United States)',
-            },
-            {
-                ...AXIRLocaleProfile,
-                code: 'fa-IR',
-                title: 'Persian (Iran)',
-                nativeTitle: 'فارسی (ایران)',
-            }
-        ];
-        this.fallbackLanguages = [
-            {
-                code: 'en',
-                title: 'English'
-            },
-            {
-                code: 'fa',
-                title: 'Persian'
-            },
-            {
-                code: 'es',
-                title: 'Spanish'
-            }
-        ];
-        this.fallbackTimeZones = [
-            {
-                code: 'America/New_York',
-                title: 'Eastern Time (US & Canada)',
-                offset: '-05:00',
-                iana: 'America/New_York',
-                abbr: 'EST'
-            },
+class AXMOidcApplicationLoader {
+    constructor(http) {
+        this.http = http;
+        this.configs = inject(AXP_ROOT_CONFIG_TOKEN);
+        this.apiGetApps = `${this.configs.baseUrl}/applications/applications-for-current-tenant`;
+        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: "20.1.3", ngImport: i0, type: AXMOidcApplicationLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcApplicationLoader }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.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: "20.1.3", ngImport: i0, type: AXMConfigurationService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMConfigurationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMConfigurationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+
+class AXMOidcFeatureLoader {
+    constructor() {
+        this.list = [
             {
-                code: 'America/Los_Angeles',
-                title: 'Pacific Time (US & Canada)',
-                offset: '-08:00',
-                iana: 'America/Los_Angeles',
-                abbr: 'PST'
+                name: 'axp-entity-list-custom-view',
+                title: 'Custom View',
+                value: false
             },
             {
-                code: 'Europe/London',
-                title: 'Greenwich Mean Time',
-                offset: '+00:00',
-                iana: 'Europe/London',
-                abbr: 'GMT'
+                name: 'axp-entity-list-quick-search',
+                title: 'Custom View',
+                value: false
             }
         ];
     }
-    //#endregion
-    async getCountries() {
-        const lang = await firstValueFrom(this.languageService.langChanges$);
-        try {
-            const countries = await firstValueFrom(this.http.get(`${this.baseUrl}/countries`).pipe(catchError(() => of(this.fallbackCountries))));
-            return countries.map((country) => {
-                if (lang == country.regional) {
-                    return {
-                        ...country,
-                        title: country.native,
-                    };
-                }
-                else {
-                    return country;
-                }
-            });
-        }
-        catch {
-            return this.fallbackCountries.map((country) => {
-                if (lang == country.regional) {
-                    return {
-                        ...country,
-                        title: country.native,
-                    };
-                }
-                else {
-                    return country;
-                }
-            });
-        }
+    getList() {
+        return of(this.list).pipe(delay(0));
     }
-    async getProvinces(countryId) {
-        let params = new HttpParams();
-        if (countryId) {
-            params = params.set('countryId', countryId);
+}
+
+//#endregion
+class AXCAPIOidcStrategy extends AXPAuthStrategy {
+    constructor() {
+        super(...arguments);
+        this.aXMAuthConfigs = inject(AXM_AUTH_CONFIG_TOKEN);
+        this.oauthService = inject(OAuthService);
+        this.http = inject(HttpClient);
+        this.sessionService = inject(AXPSessionService);
+        this.router = inject(Router);
+    }
+    async configureOAuth() {
+        if (this.openidConfigurationInfo)
+            return;
+        if (!this.authConfig) {
+            if (!this.aXMAuthConfigs.authConfig) {
+                throw new Error('authConfig is missing');
+            }
+            this.authConfig = this.aXMAuthConfigs.authConfig;
         }
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/provinces`, { params }).pipe(catchError(() => of(this.fallbackProvinces))));
+        this.oauthService.configure(this.authConfig);
+        this.oauthService.setStorage(localStorage);
+        this.openidConfigurationInfo = await this.oauthService.loadDiscoveryDocument();
+        if (!this.openidConfigurationInfo) {
+            throw new Error('openidConfigurationInfo is missing');
         }
-        catch {
-            return this.fallbackProvinces;
+        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.sessionService.setSession(authData);
+                if (authData.expiresIn && new Date(authData.expiresIn) < new Date()) {
+                    if (authData.expiresIn) {
+                        this.sessionService.refreshToken();
+                    }
+                    else {
+                        this.signout();
+                    }
+                }
+            }
         }
     }
-    async getCities(filter) {
-        let params = new HttpParams();
-        if (filter?.countryId) {
-            params = params.set('countryId', filter.countryId);
+    async signin(credentials) {
+        // If OIDC with username/password
+        if (credentials.strategy === 'oidc' && credentials.username && credentials.password) {
+            await this.handleOidcPasswordSignin(credentials);
+            await new Promise(() => { }); // Keeps the promise pending until another flow (e.g., OAuth callback) completes
         }
-        if (filter?.provinceId) {
-            params = params.set('provinceId', filter.provinceId);
+        throw new Error(`Authentication method or credentials not supported: ${credentials.strategy}`);
+    }
+    async handleOidcPasswordSignin(credentials) {
+        await this.configureOAuth();
+        const loginRes = await fetch(this.authConfig.issuer + '/api/auth/manual-login', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ username: credentials.username, password: credentials.password }),
+            credentials: 'include',
+        });
+        if (!loginRes.ok) {
+            let errorText = 'Login failed';
+            try {
+                const errorJson = await loginRes.json();
+                if (errorJson && errorJson.error && errorJson.error.description) {
+                    errorText = errorJson.error.description;
+                }
+            }
+            catch {
+                try {
+                    const text = await loginRes.text();
+                    if (text) {
+                        errorText = text;
+                    }
+                }
+                catch { }
+            }
+            throw new Error(errorText);
         }
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/cities`, { params }).pipe(catchError(() => of(this.fallbackCities))));
+        // Check if response is JSON or text
+        const contentType = loginRes.headers.get('content-type');
+        let result;
+        if (contentType && contentType.includes('application/json')) {
+            result = await loginRes.json();
         }
-        catch {
-            return this.fallbackCities;
+        else {
+            // Handle text response (like "Login successful")
+            const responseText = await loginRes.text();
+            console.log('Server response:', responseText);
         }
+        await this.updateToken({});
     }
-    async getCurrencies() {
+    async updateToken(params) {
         try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/currencies`).pipe(catchError(() => of(this.fallbackCurrencies))));
+            // Ensure OAuth is configured first
+            if (!this.openidConfigurationInfo) {
+                await this.configureOAuth();
+            }
+            // get Token Code
+            if (params['code']) {
+                // If params contains 'code', exchange it for tokens using the OpenIddict token endpoint
+                const code = params['code'];
+                const redirectUri = params['redirectUri'] || this.authConfig.redirectUri;
+                const clientId = params['clientId'] || this.authConfig.clientId;
+                const tokenEndpoint = params['tokenEndpoint'] ||
+                    this.openidConfigurationInfo?.info?.discoveryDocument?.token_endpoint ||
+                    `${this.aXMAuthConfigs?.authConfig?.issuer}/connect/token`;
+                // Get code_verifier from localStorage (PKCE)
+                const codeVerifier = localStorage.getItem('pkce_code_verifier');
+                localStorage.removeItem('pkce_code_verifier');
+                if (!codeVerifier) {
+                    throw new Error('Code verifier not found. Please try signing in again.');
+                }
+                // Prepare body for token request
+                const body = new URLSearchParams({
+                    grant_type: 'authorization_code',
+                    client_id: clientId,
+                    code_verifier: codeVerifier,
+                    code: code,
+                    redirect_uri: redirectUri,
+                });
+                // Call the token endpoint (OpenIddict)
+                const response = await fetch(tokenEndpoint, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                    body: body.toString(),
+                });
+                if (!response.ok) {
+                    throw new Error(`Token exchange failed: ${response.status} ${response.statusText}`);
+                }
+                const tokenData = await response.json();
+                if (!tokenData) {
+                    throw new Error('Token data not found');
+                }
+                const payload = JwtUtil.parseJwt(tokenData.id_token);
+                if (!payload) {
+                    throw new Error('Payload not found');
+                }
+                const user = {
+                    id: payload['sub'] || payload['http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier'] || '',
+                    title: payload['name'] || payload['email'] || '',
+                    name: payload['name'] || payload['email'] || '',
+                    avatar: payload['picture'] || '',
+                };
+                const tenant = payload['tenantid'] || payload['tenant']
+                    ? {
+                        id: payload['tenantid'] || payload['tenant'] || '',
+                        name: payload['tenantname'] || '',
+                        title: payload['tenanttitle'] || '',
+                    }
+                    : undefined;
+                const application = payload['applicationid'] || payload['application']
+                    ? {
+                        id: payload['applicationid'] || payload['application'] || '',
+                        name: payload['applicationname'] || '',
+                        title: payload['applicationtitle'] || '',
+                    }
+                    : undefined;
+                console.log('payload', payload);
+                return {
+                    succeed: true,
+                    data: {
+                        accessToken: tokenData.access_token,
+                        refreshToken: tokenData.refresh_token,
+                        idToken: tokenData.id_token,
+                        expiresIn: TimeUtil.calculateExpireInDate(tokenData.expires_in || 0),
+                        user,
+                        tenant,
+                        application,
+                    },
+                };
+            }
+            // get Authorizeation Code
+            else {
+                // Extract parameters
+                // Support both direct id fields and nested tenant/application objects
+                const tenantId = params['tenantId'] ?? params['tenant']?.id ?? null;
+                const applicationId = params['applicationId'] ?? params['application']?.id ?? null;
+                const redirectUri = params['redirectUri'] || this.authConfig.redirectUri;
+                const scope = params['scope'] || this.authConfig.scope;
+                // Generate PKCE code verifier and challenge
+                const codeVerifier = PkceUtil.generateRandomString(128);
+                localStorage.setItem('pkce_code_verifier', codeVerifier);
+                const codeChallenge = await PkceUtil.generateCodeChallenge(codeVerifier);
+                // Build authorization URL
+                const authorizeEndpoint = this.openidConfigurationInfo.info.discoveryDocument.authorization_endpoint;
+                const clientId = this.authConfig.clientId;
+                const responseType = 'code';
+                const state = Math.random().toString(36).substring(2);
+                // const authorizeUrl = `${authorizeEndpoint}?response_type=${encodeURIComponent(responseType)}&client_id=${encodeURIComponent(clientId)}&redirect_uri=${encodeURIComponent(redirectUri)}&scope=${encodeURIComponent(scope)}&state=${encodeURIComponent(state)}&tenant_id=${encodeURIComponent(tenantId)}&application_id=${encodeURIComponent(applicationId)}&code_challenge=${encodeURIComponent(codeChallenge)}&code_challenge_method=S256`;
+                // Build query params dynamically, only add tenant_id and application_id if they have values
+                const queryParams = [
+                    `response_type=${encodeURIComponent(responseType)}`,
+                    `client_id=${encodeURIComponent(clientId)}`,
+                    `redirect_uri=${encodeURIComponent(redirectUri)}`,
+                    `scope=${encodeURIComponent(scope)}`,
+                    `state=${encodeURIComponent(state)}`,
+                    tenantId ? `tenant_id=${encodeURIComponent(tenantId)}` : null,
+                    applicationId ? `application_id=${encodeURIComponent(applicationId)}` : null,
+                    `code_challenge=${encodeURIComponent(codeChallenge)}`,
+                    `code_challenge_method=S256`,
+                ]
+                    .filter(Boolean)
+                    .join('&');
+                const authorizeUrl = `${authorizeEndpoint}?${queryParams}`;
+                // Step 1: Redirect to authorization endpoint
+                window.location.href = authorizeUrl;
+            }
         }
-        catch {
-            return this.fallbackCurrencies;
+        catch (error) {
+            this.handleError(error);
         }
     }
-    async getLocaleProfiles() {
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/locale-profiles`).pipe(catchError(() => of(this.fallbackLocaleProfiles))));
-        }
-        catch {
-            return this.fallbackLocaleProfiles;
-        }
+    async signout() {
+        debugger;
+        localStorage.removeItem('pkce_code_verifier');
+        localStorage.removeItem('oauth_provider');
+        debugger;
+        console.log(this.openidConfigurationInfo?.info?.discoveryDocument);
+        const logoutUrl = `${this.aXMAuthConfigs?.authConfig?.issuer}/connect/logout`;
+        // Use GET instead of POST to avoid Content-Type header issues
+        await firstValueFrom(this.http.get(logoutUrl, { withCredentials: true }));
     }
-    async getLanguages() {
+    async refreshToken(context) {
         try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/languages`).pipe(catchError(() => of(this.fallbackLanguages))));
+            await this.configureOAuth();
+            if (!this.authConfig || !this.authConfig.clientId) {
+                throw new Error('authConfig or clientId is missing');
+            }
+            const authData = this.loadAuthData();
+            if (!authData) {
+                return { succeed: false };
+            }
+            const refreshToken = authData.refreshToken;
+            if (!refreshToken) {
+                return { succeed: false };
+            }
+            const body = new HttpParams()
+                .set('grant_type', 'refresh_token')
+                .set('client_id', this.authConfig.clientId)
+                .set('refresh_token', refreshToken);
+            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 }));
+            // Extract user, tenant, and application from id_token
+            const payload = JwtUtil.parseJwt(response.id_token);
+            const user = {
+                id: payload['sub'] || payload['http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier'] || '',
+                title: payload['name'] || payload['email'] || '',
+                name: payload['name'] || payload['email'] || '',
+                avatar: payload['picture'] || '',
+            };
+            const tenant = payload['tenantid'] || payload['tenant']
+                ? {
+                    id: payload['tenantid'] || payload['tenant'] || '',
+                    name: payload['tenantname'] || '',
+                    title: payload['tenanttitle'] || '',
+                }
+                : undefined;
+            const application = payload['applicationid'] || payload['application']
+                ? {
+                    id: payload['applicationid'] || payload['application'] || '',
+                    name: payload['applicationname'] || '',
+                    title: payload['applicationtitle'] || '',
+                }
+                : undefined;
+            const sessionData = {
+                accessToken: response.access_token,
+                refreshToken: response.refresh_token,
+                idToken: response.id_token,
+                strategy: 'oidc',
+                expiresIn: TimeUtil.calculateExpireInDate(response.expires_in ?? 0),
+                user,
+                tenant,
+                application,
+            };
+            // this.setServiceProps(sessionData);
+            return {
+                succeed: true,
+                data: {
+                    ...sessionData,
+                    user: sessionData.user, // Ensure user is not undefined
+                },
+            };
         }
-        catch {
-            return this.fallbackLanguages;
+        catch (error) {
+            console.error('Error refreshing token', error);
+            return { succeed: false };
         }
     }
-    async getAvailableLanguages() {
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/available-languages`).pipe(catchError(() => of(this.fallbackLanguages))));
-        }
-        catch {
-            return this.fallbackLanguages;
-        }
+    loadAuthData() {
+        const sessionData = this.sessionService.getSessionData();
+        return sessionData || undefined;
     }
-    async getBrowserTimeZoneCode() {
-        return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    async loadUserInfo() {
+        return this.oauthService.loadUserProfile();
     }
-    async getTimeZones() {
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/timezones`).pipe(catchError(() => of(this.fallbackTimeZones))));
-        }
-        catch {
-            return this.fallbackTimeZones;
-        }
+    handleError(error) {
+        console.error('Authentication error:', error);
+        throw error;
+    }
+    //#region getter
+    get name() {
+        return 'oidc';
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCAPIOidcStrategy, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCAPIOidcStrategy }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCAPIOidcStrategy, 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: "20.1.3", ngImport: i0, type: AXMOidcPermissionLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcPermissionLoader }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.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}/tenants/available-for-user`;
+    }
+    getList() {
+        return this.http.get(this.apiGetTenants).pipe(map((response) => response.items.map((item) => {
+            return 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: "20.1.3", ngImport: i0, type: AXMOidcTenantLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcTenantLoader }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcTenantLoader, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
 
 class AXCApiModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
@@ -921,10 +1029,10 @@ class AXCApiModule {
                 provide: AXPFileStorageService,
                 useClass: AXCFileStorageApiService,
             },
-            // {
-            //   provide: AXP_TENANT_LOADER,
-            //   useClass: AXMOidcTenantLoader,
-            // },
+            {
+                provide: AXP_TENANT_LOADER,
+                useClass: AXMOidcTenantLoader,
+            },
             {
                 provide: AXP_APPLICATION_LOADER,
                 useClass: AXMOidcApplicationLoader,
@@ -946,7 +1054,7 @@ class AXCApiModule {
             },
         ], imports: [OAuthModule.forRoot(),
             AXPAuthModule.forRoot({
-                strategies: [],
+                strategies: [AXCAPIOidcStrategy],
             })] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiModule, decorators: [{
@@ -955,7 +1063,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
                     imports: [
                         OAuthModule.forRoot(),
                         AXPAuthModule.forRoot({
-                            strategies: [],
+                            strategies: [AXCAPIOidcStrategy],
                         }),
                     ],
                     providers: [
@@ -971,10 +1079,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
                             provide: AXPFileStorageService,
                             useClass: AXCFileStorageApiService,
                         },
-                        // {
-                        //   provide: AXP_TENANT_LOADER,
-                        //   useClass: AXMOidcTenantLoader,
-                        // },
+                        {
+                            provide: AXP_TENANT_LOADER,
+                            useClass: AXMOidcTenantLoader,
+                        },
                         {
                             provide: AXP_APPLICATION_LOADER,
                             useClass: AXMOidcApplicationLoader,
@@ -1002,5 +1110,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AXCApiEntityStorageService, AXCApiModule, AXMConfigurationService, AXMOidcApplicationLoader, AXMOidcFeatureLoader, AXMOidcPermissionLoader, AXMOidcStrategy, AXMOidcTenantLoader };
+export { AXCAPIOidcStrategy, AXCApiEntityStorageService, AXCApiModule, AXMConfigurationService, AXMOidcApplicationLoader, AXMOidcFeatureLoader, AXMOidcPermissionLoader, AXMOidcTenantLoader };
 //# sourceMappingURL=acorex-connectivity-api.mjs.map