@acorex/connectivity 20.1.0 → 20.2.0-next.0

package/fesm2022/acorex-connectivity-api.mjs

@@ -1,19 +1,19 @@
-import { AXP_ROOT_CONFIG_TOKEN, AXPFilterOperatorMiddlewareService, AXPRegionalService, AXPFileStorageService, AXPFileStorageStatus } from '@acorex/platform/common';
+import { AXP_ROOT_CONFIG_TOKEN, AXPFilterOperatorMiddlewareService, AXPFileStorageService, AXPFileStorageStatus, AXPRegionalService } 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, catchError, of, map, BehaviorSubject, tap, filter, take, switchMap, delay } from 'rxjs';
+import { firstValueFrom, map, BehaviorSubject, tap, filter, take, of, switchMap, delay, catchError } from 'rxjs';
 import * as i2 from '@acorex/platform/auth';
-import { AXPAuthStrategy, AXPSessionService, AXPAuthModule, AXP_TENANT_LOADER, AXP_APPLICATION_LOADER, AXP_PERMISSION_LOADER, AXP_FEATURE_LOADER } from '@acorex/platform/auth';
+import { AXPSessionService, AXPAuthModule, 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';
 
 class AXCApiEntityStorageService {
     constructor(http) {
@@ -138,252 +138,386 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
             type: Injectable
         }], ctorParameters: () => [{ type: i1.HttpClient }] });
 
-class AXCRegionalApiService extends AXPRegionalService {
+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() {
-        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'
-            },
+        this.list = [
             {
-                code: 'LA',
-                title: 'Los Angeles',
-                native: 'Los Angeles',
-                timezone: 'America/Los_Angeles'
+                name: 'axp-entity-list-custom-view',
+                title: 'Custom View',
+                value: false
             },
             {
-                code: 'TOR',
-                title: 'Toronto',
-                native: 'Toronto',
-                timezone: 'America/Toronto'
+                name: 'axp-entity-list-quick-search',
+                title: 'Custom View',
+                value: 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}'
+    }
+    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.fallbackLocaleProfiles = [
-            {
-                ...AXUSLocaleProfile,
-                code: 'en-US',
-                title: 'English (United States)',
-                nativeTitle: 'English (United States)',
-            },
-            {
-                ...AXIRLocaleProfile,
-                code: 'fa-IR',
-                title: 'Persian (Iran)',
-                nativeTitle: 'فارسی (ایران)',
+            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();
+                    }
+                }
             }
-        ];
-        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'
-            }
-        ];
+        }
     }
-    //#endregion
-    async getCountries() {
-        const lang = await firstValueFrom(this.languageService.langChanges$);
+    async signin(credentials) {
+        await this.configureOAuth();
         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;
-                }
+            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 {
-            return this.fallbackCountries.map((country) => {
-                if (lang == country.regional) {
-                    return {
-                        ...country,
-                        title: country.native,
-                    };
-                }
-                else {
-                    return country;
-                }
-            });
+        catch (error) {
+            this.handleError(error);
         }
     }
-    async getProvinces(countryId) {
-        let params = new HttpParams();
-        if (countryId) {
-            params = params.set('countryId', countryId);
-        }
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/provinces`, { params }).pipe(catchError(() => of(this.fallbackProvinces))));
-        }
-        catch {
-            return this.fallbackProvinces;
-        }
+    async signout() {
+        //this.logout();
     }
-    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);
-        }
+    async refreshToken(context) {
         try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/cities`, { params }).pipe(catchError(() => of(this.fallbackCities))));
+            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 {
-            return this.fallbackCities;
+        catch (error) {
+            console.error('Error refreshing token', error);
+            return { succeed: false };
         }
     }
-    async getCurrencies() {
+    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 {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/currencies`).pipe(catchError(() => of(this.fallbackCurrencies))));
+            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 {
-            return this.fallbackCurrencies;
+        catch (error) {
+            console.error('Token refresh error', error);
+            return false;
         }
     }
-    async getLocaleProfiles() {
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/locale-profiles`).pipe(catchError(() => of(this.fallbackLocaleProfiles))));
-        }
-        catch {
-            return this.fallbackLocaleProfiles;
+    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{
+            // }
         }
     }
-    async getLanguages() {
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/languages`).pipe(catchError(() => of(this.fallbackLanguages))));
-        }
-        catch {
-            return this.fallbackLanguages;
-        }
+    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 getAvailableLanguages() {
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/available-languages`).pipe(catchError(() => of(this.fallbackLanguages))));
-        }
-        catch {
-            return this.fallbackLanguages;
-        }
+    async loadUserInfo() {
+        return this.oauthService.loadUserProfile();
     }
-    async getBrowserTimeZoneCode() {
-        return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    calculateExpireInDate(expireInMilisecound) {
+        return new Date(Date.now() + expireInMilisecound * 1000).toISOString();
     }
-    async getTimeZones() {
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/timezones`).pipe(catchError(() => of(this.fallbackTimeZones))));
+    logout() {
+        this.oauthService.logOut({
+            noRedirectToLogoutUrl: true,
+        });
+    }
+    handleError(error) {
+        if (error?.reason) {
+            throw new Error(JSON.stringify(error.reason));
         }
-        catch {
-            return this.fallbackTimeZones;
+        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: "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`;
+    }
+    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 AXCFileStorageApiService extends AXPFileStorageService {
     constructor() {
@@ -524,691 +658,252 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
             type: Injectable
         }] });
 
-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 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);
-    }
-    async configureOAuth() {
-        if (this.openidConfigurationInfo)
-            return;
-        if (!this.authConfig) {
-            if (!this.aXMAuthConfigs.authConfig) {
-                throw new Error('authConfig is missing');
+        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.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.sessionService.setSession(authData);
-                if (authData.expiresIn && new Date(authData.expiresIn) < new Date()) {
-                    if (authData.expiresIn) {
-                        this.sessionService.refreshToken();
-                    }
-                    else {
-                        this.signout();
-                    }
-                }
+        ];
+        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'
+            },
+            {
+                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 signin(credentials) {
-        // If OIDC with username/password
-        if (credentials.strategy === 'oidc' && credentials.username && credentials.password) {
-            return this.handleOidcPasswordSignin(credentials);
-        }
-        // If OIDC with idToken/accessToken (OAuth callback)
-        if (credentials.strategy === 'oidc' && credentials['idToken'] && credentials['accessToken']) {
-            const payload = JwtUtil.parseJwt(credentials['idToken']);
-            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'] || 'test',
-                    title: payload['tenanttitle'] || '',
+    //#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,
+                    };
                 }
-                : undefined;
-            const application = payload['applicationid'] || payload['application']
-                ? {
-                    id: payload['applicationid'] || payload['application'] || '',
-                    name: payload['applicationname'] || '',
-                    title: payload['applicationtitle'] || '',
+                else {
+                    return country;
                 }
-                : undefined;
-            return {
-                succeed: true,
-                data: {
-                    accessToken: credentials['accessToken'],
-                    refreshToken: credentials['refreshToken'],
-                    idToken: credentials['idToken'],
-                    user,
-                    tenant,
-                    application,
-                },
-            };
+            });
         }
-        throw new Error(`Unsupported authentication strategy or credentials: ${credentials.strategy}`);
-    }
-    /**
-     * Handles OIDC password-based authentication
-     */
-    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 {
+            return this.fallbackCountries.map((country) => {
+                if (lang == country.regional) {
+                    return {
+                        ...country,
+                        title: country.native,
+                    };
                 }
-            }
-            catch {
-                try {
-                    const text = await loginRes.text();
-                    if (text) {
-                        errorText = text;
-                    }
+                else {
+                    return country;
                 }
-                catch { }
-            }
-            throw new Error(errorText);
+            });
         }
-        // Redirect to authorization endpoint (this will reload the page)
-        await this.startAuthorizationFlow('', '');
-        // Return a Promise that never resolves, so the sessionService/component does not proceed
-        return new Promise(() => { });
     }
-    // private async handleOidcPasswordSignin(credentials: AXPUserPassCredentials): Promise<AXPSignInResult> {
-    //   await this.configureOAuth();
-    //   try {
-    //     const body = new HttpParams()
-    //       .set('grant_type', 'password')
-    //       .set('client_id', this.authConfig.clientId!)
-    //       .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<IAuthenticationDataModel>(
-    //         this.openidConfigurationInfo.info.discoveryDocument.token_endpoint,
-    //         body.toString(),
-    //         { headers },
-    //       ),
-    //     );
-    //     // Parse id_token to extract user, tenant, and application info
-    //     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'] || '',
-    //     } as AXPUser;
-    //     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;
-    //     return {
-    //       succeed: true,
-    //       data: {
-    //         accessToken: response.access_token,
-    //         expiresIn: this.calculateExpireInDate(response.expires_in ?? 0),
-    //         idToken: response.id_token,
-    //         refreshToken: response.refresh_token!,
-    //         user,
-    //         tenant,
-    //         application,
-    //       },
-    //     };
-    //   } catch (error: any) {
-    //     this.handleError(error);
-    //   }
-    // }
-    async signout() {
-        localStorage.removeItem('pkce_code_verifier');
-        localStorage.removeItem('oauth_provider');
-        const logoutUrl = `${this.aXMAuthConfigs?.authConfig?.issuer}/api/auth/logout`;
-        await firstValueFrom(this.http.post(logoutUrl, {}, { withCredentials: true }));
-    }
-    async refreshToken(context) {
+    async getProvinces(countryId) {
+        let params = new HttpParams();
+        if (countryId) {
+            params = params.set('countryId', countryId);
+        }
         try {
-            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: this.calculateExpireInDate(response.expires_in ?? 0),
-                user,
-                tenant,
-                application,
-            };
-            // this.setServiceProps(sessionData);
-            return {
-                succeed: true,
-                data: sessionData,
-            };
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/provinces`, { params }).pipe(catchError(() => of(this.fallbackProvinces))));
         }
-        catch (error) {
-            console.error('Error refreshing token', error);
-            return { succeed: false };
+        catch {
+            return this.fallbackProvinces;
         }
     }
-    /**
-     * Starts the OIDC authorization code flow, redirecting to the authorize endpoint with tenant_id and application_id as query params.
-     */
-    async startAuthorizationFlow(tenantId, applicationId) {
-        if (!this.openidConfigurationInfo) {
-            await this.configureOAuth();
+    async getCities(filter) {
+        let params = new HttpParams();
+        if (filter?.countryId) {
+            params = params.set('countryId', filter.countryId);
         }
-        // فقط اینجا مقداردهی شود:
-        const codeVerifier = this.generateRandomString(128);
-        localStorage.setItem('pkce_code_verifier', codeVerifier);
-        const codeChallenge = await this.generateCodeChallenge(codeVerifier);
-        const authorizeEndpoint = this.openidConfigurationInfo.info.discoveryDocument.authorization_endpoint;
-        const clientId = this.authConfig.clientId;
-        const redirectUri = this.authConfig.redirectUri;
-        const scope = this.authConfig.scope;
-        const responseType = 'code';
-        const state = Math.random().toString(36).substring(2);
-        const url = `${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`;
-        window.location.href = url;
-    }
-    /**
-     * Unified method to complete the authorization code flow.
-     */
-    async completeAuthorizationCodeFlow(options) {
-        // Ensure OAuth is configured first
-        if (!this.openidConfigurationInfo) {
-            await this.configureOAuth();
+        if (filter?.provinceId) {
+            params = params.set('provinceId', filter.provinceId);
         }
-        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.');
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/cities`, { params }).pipe(catchError(() => of(this.fallbackCities))));
         }
-        // Removed provider logic
-        const tokenEndpoint = options.tokenEndpoint ||
-            this.openidConfigurationInfo?.info?.discoveryDocument?.token_endpoint ||
-            `${this.aXMAuthConfigs?.authConfig?.issuer}/connect/token`;
-        const clientId = options.clientId || this.authConfig?.clientId || this.aXMAuthConfigs?.authConfig?.clientId || 'spa-client';
-        // Use the passed redirectUri parameter
-        const redirectUri = options.redirectUri;
-        const body = new URLSearchParams({
-            grant_type: 'authorization_code',
-            client_id: clientId,
-            code_verifier: codeVerifier,
-            code: options.code,
-            redirect_uri: redirectUri,
-        });
-        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}`);
+        catch {
+            return this.fallbackCities;
         }
-        const tokenData = await response.json();
-        const credentials = {
-            strategy: 'oidc',
-            accessToken: tokenData.access_token,
-            refreshToken: tokenData.refresh_token,
-            idToken: tokenData.id_token,
-            // Optionally, you can add user info if your signin supports it
-        };
-        await this.sessionService.signin(credentials);
-    }
-    // Helper methods:
-    generateRandomString(length) {
-        const array = new Uint8Array(length);
-        crypto.getRandomValues(array);
-        return this.base64UrlEncode(array);
-    }
-    async generateCodeChallenge(codeVerifier) {
-        const encoder = new TextEncoder();
-        const data = encoder.encode(codeVerifier);
-        const digest = await crypto.subtle.digest('SHA-256', data);
-        return this.base64UrlEncode(new Uint8Array(digest));
-    }
-    base64UrlEncode(array) {
-        return btoa(String.fromCharCode(...array))
-            .replace(/\+/g, '-')
-            .replace(/\//g, '_')
-            .replace(/=/g, '');
-    }
-    expires_in_milisecound(expires_in_date) {
-        return new Date(expires_in_date).getTime() - new Date().getTime();
-    }
-    loadAuthData() {
-        const sessionData = this.sessionService.getSessionData();
-        return sessionData || undefined;
-    }
-    async loadUserInfo() {
-        return this.oauthService.loadUserProfile();
-    }
-    calculateExpireInDate(expireInMilisecound) {
-        return new Date(Date.now() + expireInMilisecound * 1000).toISOString();
-    }
-    // private logout(): void {
-    //   // this.oauthService.logOut();
-    //   // Use the public signout method instead of private clearSession
-    //   this.sessionService.signout();
-    // }
-    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 JwtUtil {
-    /**
-     * Decodes a JWT token and returns its payload as an object.
-     * @param token JWT string
-     */
-    static parseJwt(token) {
+    async getCurrencies() {
         try {
-            return JSON.parse(atob(token.split('.')[1]));
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/currencies`).pipe(catchError(() => of(this.fallbackCurrencies))));
         }
-        catch (e) {
-            return null;
+        catch {
+            return this.fallbackCurrencies;
         }
     }
-    static createJwt(payload) {
-        // Create a proper JWT token with header, payload, and signature
-        const header = {
-            alg: 'HS256',
-            typ: 'JWT'
-        };
-        const headerEncoded = JwtUtil.base64url(header);
-        const payloadEncoded = JwtUtil.base64url(payload);
-        const signature = 'mock-signature-for-testing'; // Mock signature
-        const signatureEncoded = JwtUtil.base64url(signature);
-        const idToken = `${headerEncoded}.${payloadEncoded}.${signatureEncoded}`;
-        return idToken;
-    }
-    // For mock, just JSON stringify as the idToken
-    // Convert idTokenPayload to a JWT-like string (header.payload.signature) so jwtutil can parse it
-    // Use base64url encoding for header and payload, and a dummy signature
-    static base64url(obj) {
-        const json = JSON.stringify(obj);
-        // Encode to UTF-8 bytes
-        let utf8 = [];
-        for (let i = 0; i < json.length; i++) {
-            const charcode = json.charCodeAt(i);
-            if (charcode < 0x80)
-                utf8.push(charcode);
-            else if (charcode < 0x800) {
-                utf8.push(0xc0 | (charcode >> 6));
-                utf8.push(0x80 | (charcode & 0x3f));
-            }
-            else if (charcode < 0xd800 || charcode >= 0xe000) {
-                utf8.push(0xe0 | (charcode >> 12));
-                utf8.push(0x80 | ((charcode >> 6) & 0x3f));
-                utf8.push(0x80 | (charcode & 0x3f));
-            }
-            else {
-                // surrogate pair
-                i++;
-                // UTF-16 encodes 0x10000-0x10FFFF by subtracting 0x10000 and
-                // splitting the 20 bits of 0x0-0xFFFFF into two halves
-                const surrogatePair = 0x10000 + (((charcode & 0x3ff) << 10) | (json.charCodeAt(i) & 0x3ff));
-                utf8.push(0xf0 | (surrogatePair >> 18));
-                utf8.push(0x80 | ((surrogatePair >> 12) & 0x3f));
-                utf8.push(0x80 | ((surrogatePair >> 6) & 0x3f));
-                utf8.push(0x80 | (surrogatePair & 0x3f));
-            }
-        }
-        // Manual base64 encoding (no Buffer, no btoa)
-        const base64abc = [
-            'A',
-            'B',
-            'C',
-            'D',
-            'E',
-            'F',
-            'G',
-            'H',
-            'I',
-            'J',
-            'K',
-            'L',
-            'M',
-            'N',
-            'O',
-            'P',
-            'Q',
-            'R',
-            'S',
-            'T',
-            'U',
-            'V',
-            'W',
-            'X',
-            'Y',
-            'Z',
-            'a',
-            'b',
-            'c',
-            'd',
-            'e',
-            'f',
-            'g',
-            'h',
-            'i',
-            'j',
-            'k',
-            'l',
-            'm',
-            'n',
-            'o',
-            'p',
-            'q',
-            'r',
-            's',
-            't',
-            'u',
-            'v',
-            'w',
-            'x',
-            'y',
-            'z',
-            '0',
-            '1',
-            '2',
-            '3',
-            '4',
-            '5',
-            '6',
-            '7',
-            '8',
-            '9',
-            '+',
-            '/',
-        ];
-        let result = '', i;
-        for (i = 0; i + 2 < utf8.length; i += 3) {
-            result += base64abc[utf8[i] >> 2];
-            result += base64abc[((utf8[i] & 0x03) << 4) | (utf8[i + 1] >> 4)];
-            result += base64abc[((utf8[i + 1] & 0x0f) << 2) | (utf8[i + 2] >> 6)];
-            result += base64abc[utf8[i + 2] & 0x3f];
+    async getLocaleProfiles() {
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/locale-profiles`).pipe(catchError(() => of(this.fallbackLocaleProfiles))));
         }
-        if (i < utf8.length) {
-            result += base64abc[utf8[i] >> 2];
-            if (i === utf8.length - 1) {
-                result += base64abc[(utf8[i] & 0x03) << 4];
-                // result += '==';
-            }
-            else {
-                result += base64abc[((utf8[i] & 0x03) << 4) | (utf8[i + 1] >> 4)];
-                result += base64abc[(utf8[i + 1] & 0x0f) << 2];
-                // result += '=';
-            }
+        catch {
+            return this.fallbackLocaleProfiles;
         }
-        // base64url encoding: replace + with -, / with _, remove =
-        return result.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-    }
-}
-
-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`;
+    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 AXCApiModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
@@ -1226,10 +921,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,
@@ -1251,7 +946,7 @@ class AXCApiModule {
             },
         ], imports: [OAuthModule.forRoot(),
             AXPAuthModule.forRoot({
-                strategies: [AXCAPIOidcStrategy],
+                strategies: [],
             })] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiModule, decorators: [{
@@ -1260,7 +955,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
                     imports: [
                         OAuthModule.forRoot(),
                         AXPAuthModule.forRoot({
-                            strategies: [AXCAPIOidcStrategy],
+                            strategies: [],
                         }),
                     ],
                     providers: [
@@ -1276,10 +971,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,
@@ -1307,5 +1002,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AXCAPIOidcStrategy, AXCApiEntityStorageService, AXCApiModule, AXMConfigurationService, AXMOidcApplicationLoader, AXMOidcFeatureLoader, AXMOidcPermissionLoader, AXMOidcTenantLoader, JwtUtil };
+export { AXCApiEntityStorageService, AXCApiModule, AXMConfigurationService, AXMOidcApplicationLoader, AXMOidcFeatureLoader, AXMOidcPermissionLoader, AXMOidcStrategy, AXMOidcTenantLoader };
 //# sourceMappingURL=acorex-connectivity-api.mjs.map