@acorex/connectivity 20.2.0-next.1 → 20.2.0-next.3

package/fesm2022/acorex-connectivity-api.mjs

@@ -1,19 +1,19 @@
-import { AXP_ROOT_CONFIG_TOKEN, AXPFilterOperatorMiddlewareService, AXPFileStorageService, AXPFileStorageStatus, AXPRegionalService } from '@acorex/platform/common';
+import { AXP_ROOT_CONFIG_TOKEN, AXPFilterOperatorMiddlewareService, 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 { Router } from '@angular/router';
+import { AXCUtilsModule, AXCExternalAuthorizationService } from '@acorex/connectivity/utils';
 
 class AXCApiEntityStorageService {
     constructor(http) {
@@ -131,13 +131,152 @@ class AXCApiEntityStorageService {
             };
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiEntityStorageService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiEntityStorageService }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXCApiEntityStorageService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXCApiEntityStorageService }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiEntityStorageService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXCApiEntityStorageService, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.HttpClient }] });
 
+class AXCFileStorageApiService extends AXPFileStorageService {
+    constructor() {
+        super(...arguments);
+        this.http = inject(HttpClient);
+        //#region ----   API Endpoints   ----
+        this.baseUrl = '/api/file-storage';
+        //#endregion
+        //#region ----   Fallback Data   ----
+        this.fallbackFileInfo = {
+            fileId: 'fallback-file-id',
+            refId: 'fallback-ref-id',
+            refType: 'fallback-ref-type',
+            category: 'fallback-category',
+            size: 0,
+            mimeType: 'application/octet-stream',
+            uploadedAt: new Date(),
+            isPublic: true,
+            isPrimary: false,
+            status: AXPFileStorageStatus.Temporary,
+            name: 'fallback-file',
+            binary: new File([''], 'fallback-file'),
+        };
+    }
+    //#endregion
+    async save(request) {
+        try {
+            const formData = new FormData();
+            formData.append('file', request.file);
+            formData.append('refId', request.refId);
+            formData.append('refType', request.refType);
+            formData.append('category', request.category);
+            if (request.name) {
+                formData.append('name', request.name);
+            }
+            if (request.path) {
+                formData.append('path', request.path);
+            }
+            if (request.isPrimary !== undefined) {
+                formData.append('isPrimary', request.isPrimary.toString());
+            }
+            if (request.status) {
+                formData.append('status', request.status);
+            }
+            if (request.metadata) {
+                formData.append('metadata', JSON.stringify(request.metadata));
+            }
+            return await firstValueFrom(this.http.post(`${this.baseUrl}/save`, formData).pipe(catchError(() => of(this.fallbackFileInfo))));
+        }
+        catch {
+            return this.fallbackFileInfo;
+        }
+    }
+    async update(request) {
+        try {
+            const updateData = {
+                metadata: request.metadata,
+            };
+            if (request.path !== undefined) {
+                updateData.path = request.path;
+            }
+            if (request.isPrimary !== undefined) {
+                updateData.isPrimary = request.isPrimary;
+            }
+            return await firstValueFrom(this.http.put(`${this.baseUrl}/update/${request.fileId}`, updateData).pipe(catchError(() => of(this.fallbackFileInfo))));
+        }
+        catch {
+            return this.fallbackFileInfo;
+        }
+    }
+    async find(request) {
+        try {
+            let params = new HttpParams();
+            if (request.refId) {
+                params = params.set('refId', request.refId);
+            }
+            if (request.refType) {
+                params = params.set('refType', request.refType);
+            }
+            if (request.category) {
+                params = params.set('category', request.category);
+            }
+            if (request.mimeType) {
+                params = params.set('mimeType', request.mimeType);
+            }
+            if (request.isPublic !== undefined) {
+                params = params.set('isPublic', request.isPublic.toString());
+            }
+            if (request.isPrimary !== undefined) {
+                params = params.set('isPrimary', request.isPrimary.toString());
+            }
+            if (request.uploadedAtRange) {
+                params = params.set('uploadedAtFrom', request.uploadedAtRange.from.toISOString());
+                params = params.set('uploadedAtTo', request.uploadedAtRange.to.toISOString());
+            }
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/find`, { params }).pipe(catchError(() => of([]))));
+        }
+        catch {
+            return [];
+        }
+    }
+    async getInfo(fileId) {
+        try {
+            return await firstValueFrom(this.http.get(`${this.baseUrl}/info/${fileId}`).pipe(catchError(() => of(this.fallbackFileInfo))));
+        }
+        catch {
+            return this.fallbackFileInfo;
+        }
+    }
+    async remove(fileId) {
+        try {
+            await firstValueFrom(this.http.delete(`${this.baseUrl}/remove/${fileId}`).pipe(catchError(() => of(void 0))));
+        }
+        catch {
+            // Silently fail in fallback mode
+        }
+    }
+    async commit(fileId) {
+        try {
+            await firstValueFrom(this.http.post(`${this.baseUrl}/commit/${fileId}`, {}).pipe(catchError(() => of(void 0))));
+        }
+        catch {
+            // Silently fail in fallback mode
+        }
+    }
+    async markForDeletion(fileId) {
+        try {
+            await firstValueFrom(this.http.post(`${this.baseUrl}/mark-for-deletion/${fileId}`, {}).pipe(catchError(() => of(void 0))));
+        }
+        catch {
+            // Silently fail in fallback mode
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXCFileStorageApiService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXCFileStorageApiService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXCFileStorageApiService, decorators: [{
+            type: Injectable
+        }] });
+
 class AXMOidcApplicationLoader {
     constructor(http) {
         this.http = http;
@@ -179,10 +318,10 @@ class AXMOidcApplicationLoader {
             // 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 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMOidcApplicationLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMOidcApplicationLoader }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcApplicationLoader, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMOidcApplicationLoader, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.HttpClient }] });
 
@@ -222,10 +361,10 @@ class AXMConfigurationService {
             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' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMConfigurationService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMConfigurationService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMConfigurationService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMConfigurationService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -252,22 +391,24 @@ class AXMOidcFeatureLoader {
     }
 }
 
-class AXMOidcStrategy {
+//#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;
+        // Validation: اطمینان از وجود authConfig
+        if (!this.aXMAuthConfigs.authConfig) {
+            throw new Error('authConfig is missing. Please check your environment configuration.');
         }
-        this.oauthService.configure(this.authConfig);
+        this.oauthService.configure(this.aXMAuthConfigs.authConfig);
         this.oauthService.setStorage(localStorage);
         this.openidConfigurationInfo = await this.oauthService.loadDiscoveryDocument();
         if (!this.openidConfigurationInfo) {
@@ -286,179 +427,290 @@ class AXMOidcStrategy {
         if (oidcJson) {
             const authData = JSON.parse(oidcJson);
             if (authData) {
-                this.setServiceProps(authData);
+                this.sessionService.setSession(authData);
                 if (authData.expiresIn && new Date(authData.expiresIn) < new Date()) {
                     if (authData.expiresIn) {
-                        // this.refresh();
+                        this.sessionService.refreshToken();
                     }
                     else {
-                        this.logout();
+                        this.signout();
                     }
                 }
             }
         }
     }
     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
+        }
+        throw new Error(`Authentication method or credentials not supported: ${credentials.strategy}`);
+    }
+    async handleOidcPasswordSignin(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,
-                    },
-                },
-            };
+        // Validation: اطمینان از وجود baseUrl
+        if (!this.aXMAuthConfigs.baseUrl) {
+            throw new Error('baseUrl is missing. Please check your environment configuration.');
         }
-        catch (error) {
-            this.handleError(error);
+        // استفاده از baseUrl از configuration
+        const baseUrl = this.aXMAuthConfigs.baseUrl;
+        const loginRes = await fetch(baseUrl + '/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);
         }
+        // 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();
+        }
+        else {
+            // Handle text response (like "Login successful")
+            const responseText = await loginRes.text();
+            console.log('Server response:', responseText);
+        }
+        await this.updateToken({});
     }
-    async signout() {
-        //this.logout();
-    }
-    async refreshToken(context) {
+    async updateToken(params) {
         try {
-            await this.configureOAuth();
-            const refreshResult = await this.refresh(context.tenant?.id, context.application?.id);
-            if (refreshResult) {
+            // Ensure OAuth is configured first
+            if (!this.openidConfigurationInfo) {
+                await this.configureOAuth();
+            }
+            // Validation: اطمینان از وجود authConfig
+            if (!this.aXMAuthConfigs.authConfig) {
+                throw new Error('authConfig is missing. Please check your environment configuration.');
+            }
+            // 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.aXMAuthConfigs.authConfig.redirectUri;
+                const clientId = params['clientId'] || this.aXMAuthConfigs.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: this.oauthService.getAccessToken(),
-                        refreshToken: this.oauthService.getRefreshToken(),
+                        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 {
-                return { succeed: false };
+                // Validation: اطمینان از وجود authConfig
+                if (!this.aXMAuthConfigs.authConfig) {
+                    throw new Error('authConfig is missing. Please check your environment configuration.');
+                }
+                // 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.aXMAuthConfigs.authConfig.redirectUri;
+                const scope = params['scope'] || this.aXMAuthConfigs.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.aXMAuthConfigs.authConfig.clientId;
+                const responseType = 'code';
+                const state = Math.random().toString(36).substring(2);
+                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}`;
+                window.location.href = authorizeUrl;
             }
         }
         catch (error) {
-            console.error('Error refreshing token', error);
-            return { succeed: false };
+            this.handleError(error);
         }
     }
-    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');
+    async signout() {
+        localStorage.removeItem('pkce_code_verifier');
+        localStorage.removeItem('oauth_provider');
+        console.log(this.openidConfigurationInfo?.info?.discoveryDocument);
+        const logoutUrl = `${this.aXMAuthConfigs?.authConfig?.issuer}/connect/logout`;
+        window.location.href = logoutUrl;
+    }
+    async refreshToken(context) {
         try {
+            await this.configureOAuth();
+            if (!this.aXMAuthConfigs.authConfig || !this.aXMAuthConfigs.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.aXMAuthConfigs.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 }));
-            this.setServiceProps({
+            // 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,
-                expiresIn: this.calculateExpireInDate(response.expires_in ?? 0),
-            });
-            return true;
+                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 (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{
-            // }
+            console.error('Error refreshing token', error);
+            return { succeed: false };
         }
     }
     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;
+        const sessionData = this.sessionService.getSessionData();
+        return sessionData || undefined;
     }
     async loadUserInfo() {
         return this.oauthService.loadUserProfile();
     }
-    calculateExpireInDate(expireInMilisecound) {
-        return new Date(Date.now() + expireInMilisecound * 1000).toISOString();
-    }
-    logout() {
-        this.oauthService.logOut({
-            noRedirectToLogoutUrl: true,
-        });
-    }
     handleError(error) {
-        if (error?.reason) {
-            throw new Error(JSON.stringify(error.reason));
-        }
-        else if (error?.message) {
-            throw new Error(error.message);
-        }
-        else {
-            throw new Error('Network or server error occurred');
-        }
+        console.error('Authentication error:', error);
+        throw error;
     }
     //#region getter
     get name() {
-        return 'user-pass';
+        return 'oidc';
     }
-    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 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXCAPIOidcStrategy, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXCAPIOidcStrategy }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcStrategy, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXCAPIOidcStrategy, decorators: [{
             type: Injectable
         }] });
 
@@ -483,10 +735,10 @@ class AXMOidcPermissionLoader {
         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 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMOidcPermissionLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMOidcPermissionLoader }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcPermissionLoader, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMOidcPermissionLoader, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.HttpClient }] });
 
@@ -512,419 +764,29 @@ class AXMOidcTenantLoader {
             // 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 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMOidcTenantLoader, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMOidcTenantLoader }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMOidcTenantLoader, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXMOidcTenantLoader, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.HttpClient }] });
 
-class AXCFileStorageApiService extends AXPFileStorageService {
-    constructor() {
-        super(...arguments);
-        this.http = inject(HttpClient);
-        //#region ----   API Endpoints   ----
-        this.baseUrl = '/api/file-storage';
-        //#endregion
-        //#region ----   Fallback Data   ----
-        this.fallbackFileInfo = {
-            fileId: 'fallback-file-id',
-            refId: 'fallback-ref-id',
-            refType: 'fallback-ref-type',
-            category: 'fallback-category',
-            size: 0,
-            mimeType: 'application/octet-stream',
-            uploadedAt: new Date(),
-            isPublic: true,
-            isPrimary: false,
-            status: AXPFileStorageStatus.Temporary,
-            name: 'fallback-file',
-            binary: new File([''], 'fallback-file'),
-        };
-    }
-    //#endregion
-    async save(request) {
-        try {
-            const formData = new FormData();
-            formData.append('file', request.file);
-            formData.append('refId', request.refId);
-            formData.append('refType', request.refType);
-            formData.append('category', request.category);
-            if (request.name) {
-                formData.append('name', request.name);
-            }
-            if (request.path) {
-                formData.append('path', request.path);
-            }
-            if (request.isPrimary !== undefined) {
-                formData.append('isPrimary', request.isPrimary.toString());
-            }
-            if (request.status) {
-                formData.append('status', request.status);
-            }
-            if (request.metadata) {
-                formData.append('metadata', JSON.stringify(request.metadata));
-            }
-            return await firstValueFrom(this.http.post(`${this.baseUrl}/save`, formData).pipe(catchError(() => of(this.fallbackFileInfo))));
-        }
-        catch {
-            return this.fallbackFileInfo;
-        }
-    }
-    async update(request) {
-        try {
-            const updateData = {
-                metadata: request.metadata,
-            };
-            if (request.path !== undefined) {
-                updateData.path = request.path;
-            }
-            if (request.isPrimary !== undefined) {
-                updateData.isPrimary = request.isPrimary;
-            }
-            return await firstValueFrom(this.http.put(`${this.baseUrl}/update/${request.fileId}`, updateData).pipe(catchError(() => of(this.fallbackFileInfo))));
-        }
-        catch {
-            return this.fallbackFileInfo;
-        }
-    }
-    async find(request) {
-        try {
-            let params = new HttpParams();
-            if (request.refId) {
-                params = params.set('refId', request.refId);
-            }
-            if (request.refType) {
-                params = params.set('refType', request.refType);
-            }
-            if (request.category) {
-                params = params.set('category', request.category);
-            }
-            if (request.mimeType) {
-                params = params.set('mimeType', request.mimeType);
-            }
-            if (request.isPublic !== undefined) {
-                params = params.set('isPublic', request.isPublic.toString());
-            }
-            if (request.isPrimary !== undefined) {
-                params = params.set('isPrimary', request.isPrimary.toString());
-            }
-            if (request.uploadedAtRange) {
-                params = params.set('uploadedAtFrom', request.uploadedAtRange.from.toISOString());
-                params = params.set('uploadedAtTo', request.uploadedAtRange.to.toISOString());
-            }
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/find`, { params }).pipe(catchError(() => of([]))));
-        }
-        catch {
-            return [];
-        }
-    }
-    async getInfo(fileId) {
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/info/${fileId}`).pipe(catchError(() => of(this.fallbackFileInfo))));
-        }
-        catch {
-            return this.fallbackFileInfo;
-        }
-    }
-    async remove(fileId) {
-        try {
-            await firstValueFrom(this.http.delete(`${this.baseUrl}/remove/${fileId}`).pipe(catchError(() => of(void 0))));
-        }
-        catch {
-            // Silently fail in fallback mode
-        }
-    }
-    async commit(fileId) {
-        try {
-            await firstValueFrom(this.http.post(`${this.baseUrl}/commit/${fileId}`, {}).pipe(catchError(() => of(void 0))));
-        }
-        catch {
-            // Silently fail in fallback mode
-        }
-    }
-    async markForDeletion(fileId) {
-        try {
-            await firstValueFrom(this.http.post(`${this.baseUrl}/mark-for-deletion/${fileId}`, {}).pipe(catchError(() => of(void 0))));
-        }
-        catch {
-            // Silently fail in fallback mode
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCFileStorageApiService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCFileStorageApiService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCFileStorageApiService, decorators: [{
-            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'
-            },
-            {
-                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$);
-        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;
-                }
-            });
-        }
-    }
-    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 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;
-        }
-    }
-    async getCurrencies() {
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/currencies`).pipe(catchError(() => of(this.fallbackCurrencies))));
-        }
-        catch {
-            return this.fallbackCurrencies;
-        }
-    }
-    async getLocaleProfiles() {
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/locale-profiles`).pipe(catchError(() => of(this.fallbackLocaleProfiles))));
-        }
-        catch {
-            return this.fallbackLocaleProfiles;
-        }
-    }
-    async getLanguages() {
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/languages`).pipe(catchError(() => of(this.fallbackLanguages))));
-        }
-        catch {
-            return this.fallbackLanguages;
-        }
-    }
-    async getAvailableLanguages() {
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/available-languages`).pipe(catchError(() => of(this.fallbackLanguages))));
-        }
-        catch {
-            return this.fallbackLanguages;
-        }
-    }
-    async getBrowserTimeZoneCode() {
-        return Intl.DateTimeFormat().resolvedOptions().timeZone;
-    }
-    async getTimeZones() {
-        try {
-            return await firstValueFrom(this.http.get(`${this.baseUrl}/timezones`).pipe(catchError(() => of(this.fallbackTimeZones))));
-        }
-        catch {
-            return this.fallbackTimeZones;
-        }
-    }
-}
-
 class AXCApiModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.3", ngImport: i0, type: AXCApiModule, imports: [i1$1.OAuthModule, i2.AXPAuthModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiModule, providers: [
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXCApiModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.4", ngImport: i0, type: AXCApiModule, imports: [i1$1.OAuthModule, i2.AXPAuthModule, AXCUtilsModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXCApiModule, providers: [
             {
                 provide: AXPEntityStorageService,
                 useClass: AXCApiEntityStorageService,
             },
-            {
-                provide: AXPRegionalService,
-                useClass: AXCRegionalApiService,
-            },
             {
                 provide: AXPFileStorageService,
                 useClass: AXCFileStorageApiService,
             },
-            // {
-            //   provide: AXP_TENANT_LOADER,
-            //   useClass: AXMOidcTenantLoader,
-            // },
+            {
+                provide: AXP_TENANT_LOADER,
+                useClass: AXMOidcTenantLoader,
+            },
             {
                 provide: AXP_APPLICATION_LOADER,
                 useClass: AXMOidcApplicationLoader,
@@ -946,35 +808,33 @@ class AXCApiModule {
             },
         ], imports: [OAuthModule.forRoot(),
             AXPAuthModule.forRoot({
-                strategies: [],
-            })] }); }
+                strategies: [AXCAPIOidcStrategy],
+            }),
+            AXCUtilsModule] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXCApiModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: AXCApiModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
                         OAuthModule.forRoot(),
                         AXPAuthModule.forRoot({
-                            strategies: [],
+                            strategies: [AXCAPIOidcStrategy],
                         }),
+                        AXCUtilsModule,
                     ],
                     providers: [
                         {
                             provide: AXPEntityStorageService,
                             useClass: AXCApiEntityStorageService,
                         },
-                        {
-                            provide: AXPRegionalService,
-                            useClass: AXCRegionalApiService,
-                        },
                         {
                             provide: AXPFileStorageService,
                             useClass: AXCFileStorageApiService,
                         },
-                        // {
-                        //   provide: AXP_TENANT_LOADER,
-                        //   useClass: AXMOidcTenantLoader,
-                        // },
+                        {
+                            provide: AXP_TENANT_LOADER,
+                            useClass: AXMOidcTenantLoader,
+                        },
                         {
                             provide: AXP_APPLICATION_LOADER,
                             useClass: AXMOidcApplicationLoader,
@@ -998,9 +858,280 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImpor
                 }]
         }] });
 
+//#region ----   Class Definition   ----
+class APIGoogleStrategy extends AXPAuthStrategy {
+    constructor() {
+        super();
+        this.aXMAuthConfigs = inject(AXM_AUTH_CONFIG_TOKEN);
+        this.oauthService = inject(OAuthService);
+        this.http = inject(HttpClient);
+        this.sessionService = inject(AXPSessionService);
+        this.router = inject(Router);
+        this.externalAuthorizationService = inject(AXCExternalAuthorizationService);
+        this.tenantLoader = inject(AXP_TENANT_LOADER);
+        this.applicationLoader = inject(AXP_APPLICATION_LOADER);
+    }
+    get name() {
+        return 'google';
+    }
+    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.sessionService.setSession(authData);
+                if (authData.expiresIn && new Date(authData.expiresIn) < new Date()) {
+                    if (authData.expiresIn) {
+                        this.sessionService.refreshToken();
+                    }
+                    else {
+                        this.signout();
+                    }
+                }
+            }
+        }
+    }
+    async signin(credentials) {
+        const providerName = credentials['strategy'];
+        await this.externalAuthorizationService.signin(providerName);
+    }
+    async signout() {
+        localStorage.removeItem('pkce_code_verifier');
+        localStorage.removeItem('oauth_provider');
+        console.log('User signed out');
+    }
+    async refreshToken(context) {
+        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 URLSearchParams({
+                grant_type: 'refresh_token',
+                client_id: this.authConfig.clientId,
+                refresh_token: refreshToken,
+            });
+            const response = await fetch(this.openidConfigurationInfo.info.discoveryDocument.token_endpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                body: body.toString(),
+            });
+            if (!response.ok) {
+                throw new Error(`Token refresh failed: ${response.status} ${response.statusText}`);
+            }
+            const tokenData = await response.json();
+            // Extract user information from the refreshed token
+            const payload = JwtUtil.parseJwt(tokenData.id_token);
+            const user = {
+                id: payload['sub'] || '',
+                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: tokenData.access_token,
+                refreshToken: tokenData.refresh_token,
+                idToken: tokenData.id_token,
+                strategy: 'google',
+                expiresIn: TimeUtil.calculateExpireInDate(tokenData.expires_in || 0),
+                user,
+                tenant,
+                application,
+            };
+            return {
+                succeed: true,
+                data: {
+                    ...sessionData,
+                    user: sessionData.user,
+                },
+            };
+        }
+        catch (error) {
+            console.error('Error refreshing token', error);
+            return { succeed: false };
+        }
+    }
+    async updateToken(params) {
+        try {
+            // Ensure OAuth is configured first
+            if (!this.openidConfigurationInfo) {
+                await this.configureOAuth();
+            }
+            // If params contains 'code', exchange it for tokens
+            if (params['code']) {
+                const code = params['code'];
+                const redirectUri = params['redirectUri'] || this.authConfig.redirectUri;
+                const clientId = params['clientId'] || this.authConfig.clientId;
+                const tokenEndpoint = this.openidConfigurationInfo.info.discoveryDocument.token_endpoint;
+                // 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
+                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');
+                }
+                // Parse the ID token to extract user information
+                const payload = JwtUtil.parseJwt(tokenData.id_token);
+                if (!payload) {
+                    throw new Error('Payload not found');
+                }
+                const user = {
+                    id: payload['sub'] || '',
+                    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;
+                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 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}`;
+                window.location.href = authorizeUrl;
+                await new Promise(() => { });
+                return;
+            }
+        }
+        catch (error) {
+            console.error('Error in updateToken:', error);
+            throw error;
+        }
+    }
+    loadAuthData() {
+        const sessionData = this.sessionService.getSessionData();
+        return sessionData || undefined;
+    }
+    handleError(error) {
+        console.error('Authentication error:', error);
+        throw error;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: APIGoogleStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: APIGoogleStrategy }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.4", ngImport: i0, type: APIGoogleStrategy, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXCApiEntityStorageService, AXCApiModule, AXMConfigurationService, AXMOidcApplicationLoader, AXMOidcFeatureLoader, AXMOidcPermissionLoader, AXMOidcStrategy, AXMOidcTenantLoader };
+export { APIGoogleStrategy, AXCAPIOidcStrategy, AXCApiEntityStorageService, AXCApiModule, AXMConfigurationService, AXMOidcApplicationLoader, AXMOidcFeatureLoader, AXMOidcPermissionLoader, AXMOidcTenantLoader };
 //# sourceMappingURL=acorex-connectivity-api.mjs.map