@elite.framework/ng.core 2.0.30 → 2.0.32

package/fesm2022/elite.framework-ng.core-services.mjs

@@ -4,15 +4,14 @@ import { throwError, catchError, map as map$1, Subject, BehaviorSubject, combine
 import * as i1 from '@angular/common/http';
 import { HttpParams, HttpClient, HttpErrorResponse } from '@angular/common/http';
 import { CORE_OPTIONS, INCUDE_LOCALIZATION_RESOURCES_TOKEN, localizations$, DISABLE_PROJECT_NAME, OTHERS_GROUP, TENANT_KEY, TENANT_NOT_FOUND_BY_NAME, CHECK_AUTHENTICATION_STATE_FN_KEY, APP_INIT_ERROR_HANDLERS } from '@elite.framework/ng.core/tokens';
-import { InternalStore, isFunction, transformStringToArray, isPlainObject, createLocalizer, createLocalizerWithFallback, interpolate, createTreeFromList, BaseTreeNode, createGroupMap, pushValueTo, noop, getPathName, deepMerge, createTokenParser } from '@elite.framework/ng.core/utils';
+import { InternalStore, createLocalizer, createLocalizerWithFallback, interpolate, isFunction, transformStringToArray, isPlainObject, createTreeFromList, BaseTreeNode, createGroupMap, pushValueTo, noop, getPathName, deepMerge, createTokenParser } from '@elite.framework/ng.core/utils';
 import { map, switchMap, tap, take, filter, mapTo, takeUntil, catchError as catchError$1 } from 'rxjs/operators';
 import { isPlatformBrowser, DOCUMENT, registerLocaleData } from '@angular/common';
-import * as i1$1 from '@ngx-translate/core';
 import Swal from 'sweetalert2';
+import compare from 'just-compare';
 import * as i2 from '@angular/router';
 import { RouterStateSnapshot, TitleStrategy, NavigationStart, NavigationError, NavigationEnd, NavigationCancel, Router, PRIMARY_OUTLET } from '@angular/router';
 import { DEFAULT_REDIRECT_KEY, NavItem, UserMenu } from '@elite.framework/ng.core/models';
-import compare from 'just-compare';
 import { toSignal } from '@angular/core/rxjs-interop';
 import { Title } from '@angular/platform-browser';
 import clone from 'just-clone';
@@ -494,95 +493,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImpor
                     args: [REQUEST]
                 }] }] });
 
-class SwalService {
-    translate;
-    defaultClass = {
-        container: 'swal2-container'
-    };
-    constructor(translate) {
-        this.translate = translate;
-    }
-    t(key) {
-        return this.translate.instant(key);
-    }
-    /** رسالة تأكيد */
-    confirm(title = this.t('Confirm.Title'), text = this.t('Confirm.Text'), confirmButtonText = this.t('Confirm.Yes'), cancelButtonText = this.t('Confirm.Cancel')) {
-        return Swal.fire({
-            icon: 'warning',
-            title,
-            text,
-            showCancelButton: true,
-            confirmButtonText,
-            cancelButtonText,
-            customClass: this.defaultClass
-        });
-    }
-    /** رسالة نجاح */
-    success(title, text, timer = 2000) {
-        return Swal.fire({
-            icon: 'success',
-            title: this.t(title),
-            text: text ? this.t(text) : undefined,
-            timer,
-            showConfirmButton: false,
-            customClass: this.defaultClass
-        });
-    }
-    /** رسالة خطأ */
-    error(title, text, footer) {
-        return Swal.fire({
-            icon: 'error',
-            title: this.t(title),
-            text: text ? this.t(text) : undefined,
-            footer: footer ? this.t(footer) : undefined,
-            customClass: this.defaultClass
-        });
-    }
-    /** رسالة معلومات */
-    info(title, text) {
-        return Swal.fire({
-            icon: 'info',
-            title: this.t(title),
-            text: text ? this.t(text) : undefined,
-            customClass: this.defaultClass
-        });
-    }
-    /** أي خيارات مخصصة */
-    alert(options) {
-        const translated = {
-            ...options,
-            title: options.title ? this.t(options.title) : undefined,
-            text: options.text ? this.t(options.text) : undefined,
-            footer: options.footer ? this.t(options.footer) : undefined,
-            customClass: this.defaultClass
-        };
-        return Swal.fire(translated);
-    }
-    /** Toast */
-    toast(title, icon = 'info', position = 'top-end', timer = 3000) {
-        const Toast = Swal.mixin({
-            toast: true,
-            position,
-            timer,
-            showConfirmButton: false,
-            customClass: this.defaultClass
-        });
-        Toast.fire({ icon, title: this.t(title) });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SwalService, deps: [{ token: i1$1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SwalService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SwalService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: i1$1.TranslateService }] });
-
 class ApplicationLocalizationService {
     restService;
     apiName = 'framework';
     get = (input, config) => this.restService.request({
         method: 'GET',
-        url: '/api/asp-net-core/framework-application-localizations',
+        url: '/asp-net-core/framework-application-localizations',
         params: { cultureName: input.cultureName, onlyDynamics: input.onlyDynamics },
     }, { apiName: this.apiName, ...config });
     constructor(restService) {
@@ -605,7 +521,7 @@ class ApplicationConfigurationService {
     get = (options, config) => this.restService.request({
         method: 'GET',
         // url: '/api/framework/application-configuration',
-        url: '/api/asp-net-core/framework-application-configurations',
+        url: '/asp-net-core/framework-application-configurations',
         params: { includeLocalizationResources: options.includeLocalizationResources },
     }, { apiName: this.apiName, ...config });
     constructor(restService) {
@@ -811,1150 +727,1234 @@ function splitKeys(keys) {
     return keys;
 }
 
-class PermissionCheckerService {
+class SessionStateService {
     configState;
-    constructor(configState) {
+    localStorageService;
+    store = new InternalStore({});
+    document = inject(DOCUMENT);
+    updateLocalStorage = () => {
+        this.localStorageService.set('abpSession', JSON.stringify(this.store.state), { expires: new Date(new Date().getTime() + 365 * 86400000), path: '/' });
+    };
+    constructor(configState, localStorageService) {
         this.configState = configState;
+        this.localStorageService = localStorageService;
+        this.init();
+        this.setInitialLanguage();
     }
-    isPolicyGranted(key, grantedPolicies) {
-        if (!key)
-            return true;
-        const orRegexp = /\|\|/g;
-        const andRegexp = /&&/g;
-        // TODO: Allow combination of ANDs & ORs
-        if (orRegexp.test(key)) {
-            const keys = key.split('||').filter(Boolean);
-            if (keys.length < 2)
-                return false;
-            return keys.some(k => this.getPolicy(k.trim(), grantedPolicies));
-        }
-        else if (andRegexp.test(key)) {
-            const keys = key.split('&&').filter(Boolean);
-            if (keys.length < 2)
-                return false;
-            return keys.every(k => this.getPolicy(k.trim(), grantedPolicies));
+    init() {
+        const session = this.localStorageService.get('abpSession');
+        if (session) {
+            this.store.set(JSON.parse(session));
         }
-        return this.getPolicy(key, grantedPolicies);
+        this.store.sliceUpdate(state => state).subscribe(this.updateLocalStorage);
     }
-    getGrantedPolicy$(key) {
-        return this.getStream().pipe(map$1(grantedPolicies => this.isPolicyGranted(key, grantedPolicies)));
+    setInitialLanguage() {
+        const appLanguage = this.getLanguage();
+        this.configState
+            .getDeep$('localization.currentCulture.cultureName')
+            .pipe(filter(cultureName => !!cultureName), take(1))
+            .subscribe(lang => {
+            if (lang.includes(';')) {
+                lang = lang.split(';')[0];
+            }
+            this.setLanguage(lang);
+        });
     }
-    isGrantedAsync(permissionName) {
-        if (!permissionName)
-            return true;
-        return this.getGrantedPolicy$(permissionName);
+    onLanguageChange$() {
+        return this.store.sliceUpdate(state => state.language);
     }
-    isGranted(permissionName) {
-        if (!permissionName)
-            return true;
-        return this.getGrantedPolicy(permissionName);
+    onTenantChange$() {
+        return this.store.sliceUpdate(state => state.tenant);
     }
-    getGrantedPolicy(key) {
-        const policies = this.getSnapshot();
-        return this.isPolicyGranted(key, policies);
+    getLanguage() {
+        return this.store.state.language;
     }
-    getStream() {
-        return this.configState.getAll$().pipe(map$1(this.mapToPolicies));
+    getLanguage$() {
+        return this.store.sliceState(state => state.language);
     }
-    getSnapshot() {
-        return this.mapToPolicies(this.configState.getAll());
+    getTenant() {
+        return this.store.state.tenant;
     }
-    mapToPolicies(applicationConfiguration) {
-        return applicationConfiguration?.auth?.grantedPolicies || {};
+    getTenant$() {
+        return this.store.sliceState(state => state.tenant);
     }
-    getPolicy(key, grantedPolicies) {
-        return grantedPolicies[key] || false;
+    setTenant(tenant) {
+        if (compare(tenant, this.store.state.tenant))
+            return;
+        this.store.set({ ...this.store.state, tenant });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: PermissionCheckerService, deps: [{ token: ConfigStateService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: PermissionCheckerService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: PermissionCheckerService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: ConfigStateService }] });
-
-const ngxPermissionsGuard = (route, state) => {
-    const guard = inject(NgxPermissionsGuard);
-    if (state instanceof RouterStateSnapshot) {
-        return guard.hasPermissions(route, state);
+    setState(session) {
+        if (compare(session, this.store.state))
+            return;
+        this.store.set({ ...this.store.state, ...session });
     }
-    return guard.hasPermissions(route);
-};
-class NgxPermissionsGuard {
-    permissions;
-    router;
-    constructor(permissions, router) {
-        this.permissions = permissions;
-        this.router = router;
+    setLanguage(language) {
+        const currentLanguage = this.store.state.language;
+        if (language !== currentLanguage) {
+            this.store.patch({ language });
+        }
+        const currentAttribute = this.document.documentElement.getAttribute('lang');
+        if (language !== currentAttribute) {
+            this.document.documentElement.setAttribute('lang', language);
+        }
     }
-    canActivate(route, state) {
-        return this.hasPermissions(route, state);
+    get application() {
+        return this.store.state.application;
     }
-    canActivateChild(route, state) {
-        return this.hasPermissions(route, state);
+    get user() {
+        return this.store.state.user;
     }
-    canLoad(route) {
-        return this.hasPermissions(route);
+    get userId() {
+        return this.user ? this.user.id : 0;
     }
-    canMatch(route) {
-        return this.hasPermissions(route);
+    get tenant() {
+        return this.store.state.tenant;
     }
-    async hasPermissions(route, state) {
-        const data = route.data?.['permissions'];
-        const only = [];
-        const except = [];
-        if (data?.only) {
-            if (isFunction(data.only)) {
-                const result = data.only(route, state);
-                only.push(...transformStringToArray(result));
-            }
-            else {
-                only.push(...transformStringToArray(data.only));
-            }
+    get branch() {
+        return this.store.state.branch;
+    }
+    /* get branchName(): BranchLoginInfoDto {
+        return this._branch ? this.branch.Name : '';
+
+    } */
+    get tenancyName() {
+        return this.store.state.tenant ? this.tenant?.tenancyName : '';
+    }
+    get branchId() {
+        // return this.branch ? this.branch.id : this.configState.Session?.branchId ? this.configState.Session.branchId:null;
+        return this.branch ? this.branch.id : 0;
+    }
+    get tenantId() {
+        return this.tenant ? this.tenant.id : 0;
+    }
+    getShownLoginName() {
+        const userName = this.store.state.user?.userName ?? '';
+        if (!this.multiTenancySide) {
+            return userName;
         }
-        if (data?.except) {
-            if (isFunction(data.except)) {
-                const result = data.except(route, state);
-                except.push(...transformStringToArray(result));
-            }
-            else {
-                except.push(...transformStringToArray(data.except));
-            }
-        }
-        const permissions = {
-            only,
-            except,
-            redirectTo: data?.redirectTo
-        };
-        // --- rest of the guard logic ---
-        // EXCEPT check
-        if (permissions.except?.length) {
-            for (const perm of permissions.except) {
-                if (await this.permissions.isGranted(perm)) {
-                    this.handleRedirect(permissions, perm, route, state);
-                    return false;
-                }
-            }
-        }
-        // ONLY check
-        if (permissions.only?.length) {
-            for (const perm of permissions.only) {
-                if (await this.permissions.isGrantedAsync(perm)) {
-                    return true;
-                }
-            }
-            this.handleRedirect(permissions, permissions.only[0], route, state);
+        return (this.store.state.tenant ? this.store.state.tenant.tenancyName : '.') + '\\' + userName;
+    }
+    changeTenantIfNeeded(tenantId) {
+        if (this.isCurrentTenant(tenantId)) {
             return false;
         }
+        // this.configState.SetTenantIdCookie(tenantId);
+        location.reload();
         return true;
     }
-    handleRedirect(permissions, failedPermission, route, state) {
-        const redirectTo = permissions.redirectTo;
-        if (!redirectTo)
-            return;
-        // If redirectTo is a function
-        const resolvedRedirect = isFunction(redirectTo)
-            ? redirectTo(failedPermission, route, state)
-            : redirectTo;
-        if (typeof resolvedRedirect === 'string') {
-            this.router.navigate([resolvedRedirect]); // wrap string in array
-        }
-        else if (Array.isArray(resolvedRedirect)) {
-            this.router.navigate(resolvedRedirect); // array is fine
-        }
-        else if (isPlainObject(resolvedRedirect)) {
-            // Object: check for failedPermission key first
-            const target = resolvedRedirect[failedPermission] ?? resolvedRedirect[DEFAULT_REDIRECT_KEY];
-            if (target) {
-                if (typeof target === 'string') {
-                    this.router.navigate([target]);
-                }
-                else if (Array.isArray(target)) {
-                    this.router.navigate(target);
-                }
-                else if (isFunction(target)) {
-                    this.router.navigate([target(failedPermission, route, state)]);
-                }
-            }
-        }
-        else {
-            console.warn('Unknown redirect type', resolvedRedirect);
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: NgxPermissionsGuard, deps: [{ token: PermissionCheckerService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: NgxPermissionsGuard, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: NgxPermissionsGuard, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: PermissionCheckerService }, { type: i2.Router }] });
-
-// logger.interface.ts
-var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
-    LogLevel[LogLevel["INFO"] = 1] = "INFO";
-    LogLevel[LogLevel["WARN"] = 2] = "WARN";
-    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
-    LogLevel[LogLevel["OFF"] = 4] = "OFF";
-})(LogLevel || (LogLevel = {}));
-
-// logger.service.ts
-// Remove the separate LoggerConfig interface since we're using EnvironmentConfig
-// and extend EnvironmentConfig to include logger-specific properties
-class LoggerService {
-    level = LogLevel.DEBUG;
-    enableConsole = true;
-    prefix = '[App]';
-    timestamp = true;
-    environmentService = inject(EnvironmentService);
-    environment = this.environmentService?.getEnvironment();
-    constructor() {
-        // Use environment configuration if provided
-        if (this.environment) {
-            this.configureFromEnvironment(this.environment);
-        }
-        // Fallback: In production, default to WARN level
-        if (typeof window !== 'undefined' && window.location.hostname !== 'localhost') {
-            this.level = LogLevel.WARN;
-            this.enableConsole = false;
-        }
-    }
-    configureFromEnvironment(env) {
-        // Map string log levels from environment to LogLevel enum
-        this.level = this.mapLogLevel(env.logLevel);
-        // Use production flag to determine console logging
-        this.enableConsole = !env.production;
-        // Set prefix from environment if available
-        this.prefix = `[${env['appName'] || 'App'}]`;
-        // Enable timestamp in development, disable in production for performance
-        this.timestamp = !env.production;
-    }
-    mapLogLevel(level) {
-        switch (level) {
-            case 'debug': return LogLevel.DEBUG;
-            case 'info': return LogLevel.INFO;
-            case 'warn': return LogLevel.WARN;
-            case 'error': return LogLevel.ERROR;
-            case 'off': return LogLevel.OFF;
-            default: return LogLevel.WARN;
+    isCurrentTenant(tenantId) {
+        let isTenant = tenantId ?? 0 > 0;
+        if (!isTenant && !this.tenant) { // this is host
+            return true;
         }
-    }
-    debug(message, ...args) {
-        if (this.shouldLog(LogLevel.DEBUG)) {
-            this.log('DEBUG', message, args, 'color: blue');
+        if (!tenantId && this.tenant) {
+            return false;
         }
-    }
-    info(message, ...args) {
-        if (this.shouldLog(LogLevel.INFO)) {
-            this.log('INFO', message, args, 'color: green');
+        else if (tenantId && (!this.tenant || this.tenant.id !== tenantId)) {
+            return false;
         }
+        return true;
     }
-    warn(message, ...args) {
-        if (this.shouldLog(LogLevel.WARN)) {
-            this.log('WARN', message, args, 'color: orange');
-        }
+    get impersonatorUser() {
+        return this.store.state.impersonatorUser;
     }
-    error(message, ...args) {
-        if (this.shouldLog(LogLevel.ERROR)) {
-            this.log('ERROR', message, args, 'color: red');
-            // Send to external services only for errors in production
-            if (this.environment?.production) {
-                this.sendToExternalService('ERROR', message, args);
-            }
-        }
+    get impersonatorUserId() {
+        return this.impersonatorUser ? this.impersonatorUser.id : 0;
     }
-    setLogLevel(level) {
-        this.level = level;
+    get impersonatorTenant() {
+        return this.store.state.impersonatorTenant;
     }
-    shouldLog(level) {
-        return level >= this.level && this.enableConsole;
+    get impersonatorTenancyName() {
+        return this.impersonatorTenant ? this.impersonatorTenant?.tenancyName ?? '' : '';
     }
-    log(level, message, args, style) {
-        if (!this.enableConsole)
-            return;
-        const timestamp = this.timestamp ? new Date().toISOString() : '';
-        const formattedPrefix = this.prefix ? `${this.prefix}` : '';
-        const logMessage = `${timestamp} ${formattedPrefix} [${level}] ${message}`;
-        if (args.length > 0) {
-            console.log(`%c${logMessage}`, style, ...args);
-        }
-        else {
-            console.log(`%c${logMessage}`, style);
-        }
+    get impersonatorTenantId() {
+        return this.impersonatorTenant ? this.impersonatorTenant.id : 0;
     }
-    sendToExternalService(level, message, args) {
-        // Integrate with external logging services from environment
-        try {
-            const sentryUrl = this.environment?.externalServices?.['sentry'];
-            const logRocketUrl = this.environment?.externalServices?.['logRocket'];
-            // Example: Send to configured external services
-            if (sentryUrl) {
-                // this.sendToSentry(level, message, args);
-            }
-            if (logRocketUrl) {
-                // this.sendToLogRocket(level, message, args);
-            }
-            // Send to backend if apiUrl is available
-            if (this.environment?.apis.default.url) {
-                // this.http.post(`${this.environment.apiUrl}/logs`, {
-                //   level, message, args, timestamp: new Date()
-                // }).subscribe();
-            }
-        }
-        catch (error) {
-            // Don't use this.error here to avoid infinite loops
-            console.error('Failed to send log to external service:', error);
-        }
+    get multiTenancySide() {
+        // return this.configState.session?.multiTenancySide;
+        return 0;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LoggerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LoggerService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SessionStateService, deps: [{ token: ConfigStateService }, { token: SsrCookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SessionStateService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LoggerService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SessionStateService, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: 'root',
                 }]
-        }], ctorParameters: () => [] });
+        }], ctorParameters: () => [{ type: ConfigStateService }, { type: SsrCookieService }] });
 
-class IdParserService {
+class LocalizationService {
+    sessionState;
+    injector;
+    configState;
+    latestLang = 'ar';
+    _languageChange$ = new Subject();
+    uiLocalizations$ = new BehaviorSubject(new Map());
+    localizations$ = new BehaviorSubject(new Map());
     /**
-     * Extract IDs from a model based on comma-separated field names.
-     * Example: "id,biId" => [model.id, model.biId]
+     * Returns currently selected language
+     * Even though this looks like it's redundant to return the same value as `getLanguage()`,
+     * it's actually not. This could be invoked any time, and the latestLang could be different from the
+     * sessionState.getLanguage() value.
      */
-    parseIds(model, idField) {
-        if (!idField)
-            return null;
-        const fields = idField.split(',').map(f => f.trim()).filter(Boolean);
-        if (fields.length === 1) {
-            return model[fields[0]];
-        }
-        return fields.map(f => model[f]);
+    get currentLanguage() {
+        return this.latestLang || this.sessionState.getLanguage();
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: IdParserService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: IdParserService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: IdParserService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-class QueryParser {
-    static parse(queryString) {
-        const params = {
-            filters: [],
-            orderBy: [],
-            groupBy: [],
-            select: [],
-            aggregates: []
-        };
-        if (!queryString)
-            return params;
-        const queryParts = queryString.split('&');
-        for (const part of queryParts) {
-            if (part.startsWith('$filter=')) {
-                this.parseFilter(part.substring('$filter='.length), params);
-            }
-            else if (part.startsWith('$orderby=')) {
-                this.parseOrderBy(part.substring('$orderby='.length), params);
-            }
-            else if (part.startsWith('$groupby=')) {
-                this.parseGroupBy(part.substring('$groupby='.length), params);
-            }
-            else if (part.startsWith('$select=')) {
-                this.parseSelect(part.substring('$select='.length), params);
-            }
-            else if (part.startsWith('$aggregate=')) {
-                this.parseAggregate(part.substring('$aggregate='.length), params);
-            }
-            else if (part.startsWith('$top=')) {
-                params.top = Number(part.substring('$top='.length));
-            }
-            else if (part.startsWith('$skip=')) {
-                params.skip = Number(part.substring('$skip='.length));
-            }
-            else if (part.startsWith('$expand=')) {
-                params.expand = part.substring('$expand='.length).split(',').map(f => f.trim());
+    get currentLang() {
+        return this.latestLang || this.sessionState.getLanguage();
+    }
+    get currentLang$() {
+        return this.sessionState.getLanguage$();
+    }
+    get languageChange$() {
+        return this._languageChange$.asObservable();
+    }
+    constructor(sessionState, injector, otherInstance, configState) {
+        this.sessionState = sessionState;
+        this.injector = injector;
+        this.configState = configState;
+        if (otherInstance)
+            throw new Error('LocalizationService should have only one instance.');
+        this.listenToSetLanguage();
+        this.initLocalizationValues();
+        this.latestLang = this.sessionState.getLanguage();
+    }
+    initLocalizationValues() {
+        localizations$.subscribe(val => this.addLocalization(val));
+        const legacyResources$ = this.configState.getDeep$('localization.values');
+        const remoteLocalizations$ = this.configState.getDeep$('localization.resources');
+        const currentLanguage$ = this.sessionState.getLanguage$();
+        const uiLocalizations$ = combineLatest([currentLanguage$, this.uiLocalizations$]).pipe(map(([currentLang, localizations]) => localizations.get(currentLang)));
+        combineLatest([legacyResources$, remoteLocalizations$, uiLocalizations$])
+            .pipe(map(([legacy, resource, local]) => {
+            if (!resource) {
+                return null;
             }
-            else if (part.startsWith('$count=')) {
-                params.includeCount = part.substring('$count='.length).toLowerCase() === 'true';
+            const remote = combineLegacyandNewResources(legacy || {}, resource);
+            if (remote) {
+                if (!local) {
+                    local = new Map();
+                }
+                Object.entries(remote).forEach(entry => {
+                    const resourceName = entry[0];
+                    const remoteTexts = entry[1];
+                    let resource = local?.get(resourceName) || {};
+                    resource = { ...resource, ...remoteTexts };
+                    local?.set(resourceName, resource);
+                });
             }
-        }
-        return params;
+            return local;
+        }), filter(Boolean))
+            .subscribe(val => this.localizations$.next(val));
     }
-    static toString(params) {
-        const parts = [];
-        if (params.filters?.length) {
-            const filterStr = this.buildFilterString(params.filters);
-            parts.push(`$filter=${encodeURIComponent(filterStr)}`);
-        }
-        if (params.orderBy?.length) {
-            const orderByStr = params.orderBy.map(o => `${o.field} ${o.direction}`).join(',');
-            parts.push(`$orderby=${encodeURIComponent(orderByStr)}`);
-        }
-        if (params.groupBy?.length) {
-            const groupByStr = this.buildGroupByString(params.groupBy);
-            parts.push(`$groupby=${encodeURIComponent(groupByStr)}`);
+    addLocalization(localizations) {
+        if (!localizations)
+            return;
+        const localizationMap = this.uiLocalizations$.value;
+        localizations.forEach(loc => {
+            const cultureMap = localizationMap.get(loc.culture) || new Map();
+            loc.resources.forEach(res => {
+                let resource = cultureMap.get(res.resourceName) || {};
+                resource = { ...resource, ...res.texts };
+                cultureMap.set(res.resourceName, resource);
+            });
+            localizationMap.set(loc.culture, cultureMap);
+        });
+        this.uiLocalizations$.next(localizationMap);
+    }
+    listenToSetLanguage() {
+        this.sessionState
+            .onLanguageChange$()
+            .pipe(filter(lang => this.configState.getDeep('localization.currentCulture.cultureName') !== lang), switchMap((lang) => this.configState.refreshLocalization(lang).pipe(map(() => lang))), filter(Boolean), switchMap((lang) => from(this.registerLocale(lang).then(() => lang))))
+            .subscribe((lang) => this._languageChange$.next(lang));
+    }
+    registerLocale(locale) {
+        const { registerLocaleFn } = this.injector.get(CORE_OPTIONS);
+        return registerLocaleFn(locale).then(module => {
+            if (module?.default)
+                registerLocaleData(module.default);
+            this.latestLang = locale;
+        });
+    }
+    /**
+     * Returns an observable localized text with the given interpolation parameters in current language.
+     * @param key Localizaton key to replace with localized text
+     * @param interpolateParams Values to interpolate
+     */
+    get(key, ...interpolateParams) {
+        return this.configState
+            .getAll$()
+            .pipe(map(state => this.getLocalization(state, key, ...interpolateParams)));
+    }
+    getResource(resourceName) {
+        return this.localizations$.value.get(resourceName);
+    }
+    getResource$(resourceName) {
+        return this.localizations$.pipe(map(res => res.get(resourceName)));
+    }
+    /**
+     * Returns localized text with the given interpolation parameters in current language.
+     * @param key Localization key to replace with localized text
+      //  const translateService = inject(TranslateService);// from '@ngx-translate/core'; // use it for fallback
+     * @param interpolateParams Values to intepolate.
+     */
+    instant(key, ...interpolateParams) {
+        return this.getLocalization(this.configState.getAll(), key, ...interpolateParams);
+    }
+    localize(resourceName, key, defaultValue) {
+        return this.configState.getOne$('localization').pipe(map(createLocalizer), map((localize) => localize(resourceName, key, defaultValue)));
+    }
+    get defaultResourceName() {
+        return this.configState.getAll().localization ? this.configState.getAll().localization.defaultResourceName : 'FrameworkLocalization';
+    }
+    l(key) {
+        const localization = this.configState.getOne('localization');
+        return createLocalizer(localization)(this.defaultResourceName ?? '', key, key);
+    }
+    localizeSync(resourceName, key, defaultValue) {
+        const localization = this.configState.getOne('localization');
+        return createLocalizer(localization)(resourceName, key, defaultValue);
+    }
+    localizeWithFallback(resourceNames, keys, defaultValue) {
+        return this.configState.getOne$('localization').pipe(map(createLocalizerWithFallback), map((localizeWithFallback) => localizeWithFallback(resourceNames, keys, defaultValue)));
+    }
+    localizeWithFallbackSync(resourceNames, keys, defaultValue) {
+        const localization = this.configState.getOne('localization');
+        return createLocalizerWithFallback(localization)(resourceNames, keys, defaultValue);
+    }
+    getLocalization(state, key, ...interpolateParams) {
+        let defaultValue = '';
+        if (!key) {
+            return defaultValue;
         }
-        if (params.select?.length) {
-            const selectStr = this.buildSelectString(params.select);
-            parts.push(`$select=${encodeURIComponent(selectStr)}`);
+        if (typeof key !== 'string') {
+            defaultValue = key.defaultValue;
+            key = key.key;
         }
-        if (params.aggregates?.length) {
-            const aggregateStr = this.buildAggregateString(params.aggregates);
-            parts.push(`$aggregate=${encodeURIComponent(aggregateStr)}`);
+        const keys = key.split('::');
+        const warn = (message) => {
+            if (isDevMode())
+                console.warn(message);
+        };
+        if (keys.length < 2) {
+            warn('The localization source separator (::) not found.');
+            return defaultValue || key;
         }
-        if (params.top !== undefined) {
-            parts.push(`$top=${params.top}`);
+        if (!state.localization)
+            return defaultValue || keys[1];
+        const sourceName = keys[0] || state.localization.defaultResourceName;
+        const sourceKey = keys[1];
+        if (sourceName === '_') {
+            return defaultValue || sourceKey;
         }
-        if (params.skip !== undefined) {
-            parts.push(`$skip=${params.skip}`);
+        if (!sourceName) {
+            warn('Localization source name is not specified and the defaultResourceName was not defined!');
+            return defaultValue || sourceKey;
         }
-        if (params.expand?.length) {
-            parts.push(`$expand=${encodeURIComponent(params.expand.join(','))}`);
+        const source = this.localizations$.value.get(sourceName);
+        if (!source) {
+            warn('Could not find localization source: ' + sourceName);
+            return defaultValue || sourceKey;
         }
-        if (params.includeCount !== undefined) {
-            parts.push(`$count=${params.includeCount}`);
+        let localization = source[sourceKey];
+        if (typeof localization === 'undefined') {
+            return defaultValue || sourceKey;
         }
-        return parts.join('&');
+        interpolateParams = interpolateParams.filter(params => params != null);
+        if (localization)
+            localization = interpolate(localization, interpolateParams);
+        if (typeof localization !== 'string')
+            localization = '';
+        return localization || defaultValue || key;
     }
-    static buildFilterString(filters) {
-        return filters.map((group, index) => {
-            const groupStr = group.conditions
-                .map(condition => {
-                let val = condition.value;
-                if (typeof val === 'string') {
-                    val = `'${val.replace(/'/g, "''")}'`;
-                }
-                else if (typeof val === 'boolean') {
-                    val = val ? 'true' : 'false';
-                }
-                return `${condition.field} ${condition.operator} ${val}`;
-            })
-                .join(` ${group.logicalOperator} `);
-            // For the first group, no groupLogicalOperator is needed
-            if (index === 0) {
-                return group.conditions.length > 1 ? `(${groupStr})` : groupStr;
-            }
-            else {
-                const joinOp = group.groupLogicalOperator || 'and';
-                return group.conditions.length > 1 ? `${joinOp} (${groupStr})` : `${joinOp} ${groupStr}`;
-            }
-        }).join(' ');
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LocalizationService, deps: [{ token: SessionStateService }, { token: i0.Injector }, { token: LocalizationService, optional: true, skipSelf: true }, { token: ConfigStateService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LocalizationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LocalizationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: SessionStateService }, { type: i0.Injector }, { type: LocalizationService, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: ConfigStateService }] });
+function recursivelyMergeBaseResources(baseResourceName, source) {
+    const item = source[baseResourceName];
+    if (item.baseResources.length === 0) {
+        return item;
     }
-    static buildGroupByString(groupBy) {
-        return groupBy
-            .sort((a, b) => (a.order || 0) - (b.order || 0))
-            .map(group => {
-            let groupStr = group.propertyName;
-            // Add display name if provided
-            if (group.displayName) {
-                groupStr += ` as ${group.displayName}`;
-            }
-            // Add metadata for UI
-            const metadata = [];
-            if (group.showTotal !== undefined) {
-                metadata.push(`showTotal:${group.showTotal}`);
-            }
-            if (group.totalBackground) {
-                metadata.push(`totalBg:${group.totalBackground}`);
-            }
-            if (group.groupHeaderBackground) {
-                metadata.push(`headerBg:${group.groupHeaderBackground}`);
-            }
-            if (metadata.length > 0) {
-                groupStr += `(${metadata.join(';')})`;
-            }
-            return groupStr;
-        })
-            .join(',');
+    return item.baseResources.reduce((acc, baseResource) => {
+        const baseItem = recursivelyMergeBaseResources(baseResource, source);
+        const texts = { ...baseItem.texts, ...item.texts };
+        return { ...acc, texts };
+    }, item);
+}
+function mergeResourcesWithBaseResource(resource) {
+    const entities = Object.keys(resource).map(key => {
+        const newValue = recursivelyMergeBaseResources(key, resource);
+        return [key, newValue];
+    });
+    return entities.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+}
+function combineLegacyandNewResources(legacy, resource) {
+    const mergedResource = mergeResourcesWithBaseResource(resource);
+    return Object.entries(mergedResource).reduce((acc, [key, value]) => {
+        return { ...acc, [key]: value.texts };
+    }, legacy);
+}
+
+class SwalService {
+    translate;
+    defaultClass = {
+        container: 'swal2-container'
+    };
+    constructor(translate) {
+        this.translate = translate;
     }
-    static buildSelectString(select) {
-        return select
-            .sort((a, b) => (a.order || 0) - (b.order || 0))
-            .map(item => {
-            let selectStr = item.propertyName;
-            // Add display name if provided
-            if (item.displayName) {
-                selectStr += ` as ${item.displayName}`;
-            }
-            // Add aggregate function if provided
-            if (item.aggregateFunction) {
-                selectStr += ` with ${item.aggregateFunction}`;
-            }
-            // Add visibility metadata
-            const metadata = [];
-            if (item.isVisible !== undefined) {
-                metadata.push(`visible:${item.isVisible}`);
-            }
-            if (metadata.length > 0) {
-                selectStr += `(${metadata.join(';')})`;
-            }
-            return selectStr;
-        })
-            .join(',');
+    t(key) {
+        return this.translate.instant(key);
     }
-    static buildAggregateString(aggregates) {
-        return aggregates
-            .map(agg => {
-            let aggStr = `${agg.aggregateFunction}(${agg.propertyName})`;
-            if (agg.alias) {
-                aggStr += ` as ${agg.alias}`;
-            }
-            return aggStr;
-        })
-            .join(',');
+    /** رسالة تأكيد */
+    confirm(title = this.t('Confirm.Title'), text = this.t('Confirm.Text'), confirmButtonText = this.t('Confirm.Yes'), cancelButtonText = this.t('Confirm.Cancel')) {
+        return Swal.fire({
+            icon: 'warning',
+            title,
+            text,
+            showCancelButton: true,
+            confirmButtonText,
+            cancelButtonText,
+            customClass: this.defaultClass
+        });
     }
-    static parseFilter(filterString, params) {
-        const decodedString = decodeURIComponent(filterString);
-        const groups = [];
-        // Split by top-level AND/OR operators
-        const topLevelPattern = /(?:^|\s)(and|or)\s+(?=(?:[^()]*\([^()]*\))*[^()]*$)/gi;
-        const segments = [];
-        let lastIndex = 0;
-        let match;
-        while ((match = topLevelPattern.exec(decodedString)) !== null) {
-            const operator = match[1];
-            const segment = decodedString.substring(lastIndex, match.index).trim();
-            if (segment) {
-                segments.push({ condition: segment, operator });
-            }
-            lastIndex = match.index + match[0].length;
-        }
-        // Add the last segment
-        const lastSegment = decodedString.substring(lastIndex).trim();
-        if (lastSegment) {
-            segments.push({ condition: lastSegment, operator: undefined });
-        }
-        // Parse each segment
-        segments.forEach((segment, index) => {
-            let conditions = [];
-            // Check if it's a group with parentheses
-            if (segment.condition.startsWith('(') && segment.condition.endsWith(')')) {
-                const innerCondition = segment.condition.slice(1, -1).trim();
-                conditions = this.parseConditions(innerCondition);
-            }
-            else {
-                // Individual condition
-                conditions = this.parseConditions(segment.condition);
-            }
-            if (conditions.length > 0) {
-                const group = {
-                    logicalOperator: 'and',
-                    conditions: conditions
-                };
-                // For groups after the first, set the groupLogicalOperator
-                if (index > 0) {
-                    group.groupLogicalOperator = segment.operator?.toLowerCase() || 'and';
-                }
-                // Detect the logical operator used within the group
-                if (conditions.length === 1 && segment.condition.includes(' or ')) {
-                    group.logicalOperator = 'or';
-                }
-                else if (conditions.length > 1) {
-                    group.logicalOperator = segment.condition.toLowerCase().includes(' or ') ? 'or' : 'and';
-                }
-                groups.push(group);
-            }
+    /** رسالة نجاح */
+    success(title, text, timer = 2000) {
+        return Swal.fire({
+            icon: 'success',
+            title: this.t(title),
+            text: text ? this.t(text) : undefined,
+            timer,
+            showConfirmButton: false,
+            customClass: this.defaultClass
         });
-        params.filters = groups;
     }
-    static parseConditions(conditionString) {
-        const conditions = [];
-        // Enhanced pattern to handle more operators and complex values
-        const pattern = /(\w+(?:\.\w+)*)\s+(eq|ne|gt|ge|lt|le|contains|startswith|endswith|in|notin)\s+('[^']*'|\[[^\]]*\]|\d+|true|false|null)/gi;
-        let match;
-        while ((match = pattern.exec(conditionString)) !== null) {
-            const [, field, operator, rawValue] = match;
-            let value = rawValue.trim();
-            if (rawValue.startsWith("'") && rawValue.endsWith("'")) {
-                value = rawValue.slice(1, -1).replace(/''/g, "'");
-            }
-            else if (rawValue.startsWith('[') && rawValue.endsWith(']')) {
-                // Handle array values for IN/NOT IN operators
-                value = rawValue.slice(1, -1).split(',').map(v => {
-                    const trimmed = v.trim().replace(/^'|'$/g, '');
-                    return isNaN(Number(trimmed)) ? trimmed : Number(trimmed);
-                });
-            }
-            else if (!isNaN(Number(rawValue))) {
-                value = Number(rawValue);
-            }
-            else if (rawValue.toLowerCase() === 'true') {
-                value = true;
-            }
-            else if (rawValue.toLowerCase() === 'false') {
-                value = false;
-            }
-            else if (rawValue.toLowerCase() === 'null') {
-                value = null;
-            }
-            conditions.push({
-                field: field.trim(),
-                operator: operator.trim().toLowerCase(),
-                value
-            });
-        }
-        return conditions;
+    /** رسالة خطأ */
+    error(title, text, footer) {
+        return Swal.fire({
+            icon: 'error',
+            title: this.t(title),
+            text: text ? this.t(text) : undefined,
+            footer: footer ? this.t(footer) : undefined,
+            customClass: this.defaultClass
+        });
     }
-    static parseOrderBy(orderByString, params) {
-        const decodedString = decodeURIComponent(orderByString);
-        const clauses = decodedString.split(',');
-        for (const clause of clauses) {
-            const parts = clause.trim().split(/\s+/);
-            const field = parts[0];
-            const direction = parts[1]?.toLowerCase() || 'asc';
-            params.orderBy?.push({
-                field,
-                direction
-            });
+    /** رسالة معلومات */
+    info(title, text) {
+        return Swal.fire({
+            icon: 'info',
+            title: this.t(title),
+            text: text ? this.t(text) : undefined,
+            customClass: this.defaultClass
+        });
+    }
+    /** أي خيارات مخصصة */
+    alert(options) {
+        const translated = {
+            ...options,
+            title: options.title ? this.t(options.title) : undefined,
+            text: options.text ? this.t(options.text) : undefined,
+            footer: options.footer ? this.t(options.footer) : undefined,
+            customClass: this.defaultClass
+        };
+        return Swal.fire(translated);
+    }
+    /** Toast */
+    toast(title, icon = 'info', position = 'top-end', timer = 3000) {
+        const Toast = Swal.mixin({
+            toast: true,
+            position,
+            timer,
+            showConfirmButton: false,
+            customClass: this.defaultClass
+        });
+        Toast.fire({ icon, title: this.t(title) });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SwalService, deps: [{ token: LocalizationService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SwalService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SwalService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: LocalizationService }] });
+
+class PermissionCheckerService {
+    configState;
+    constructor(configState) {
+        this.configState = configState;
+    }
+    isPolicyGranted(key, grantedPolicies) {
+        if (!key)
+            return true;
+        const orRegexp = /\|\|/g;
+        const andRegexp = /&&/g;
+        // TODO: Allow combination of ANDs & ORs
+        if (orRegexp.test(key)) {
+            const keys = key.split('||').filter(Boolean);
+            if (keys.length < 2)
+                return false;
+            return keys.some(k => this.getPolicy(k.trim(), grantedPolicies));
+        }
+        else if (andRegexp.test(key)) {
+            const keys = key.split('&&').filter(Boolean);
+            if (keys.length < 2)
+                return false;
+            return keys.every(k => this.getPolicy(k.trim(), grantedPolicies));
         }
+        return this.getPolicy(key, grantedPolicies);
     }
-    static parseGroupBy(groupByString, params) {
-        const decodedString = decodeURIComponent(groupByString);
-        const groups = decodedString.split(',');
-        params.groupBy = groups.map((groupStr, index) => {
-            const group = {
-                propertyName: '',
-                order: index
-            };
-            // Check for metadata in parentheses
-            const metadataMatch = groupStr.match(/^(.*?)\((.*)\)$/);
-            let baseStr = groupStr;
-            let metadataStr = '';
-            if (metadataMatch) {
-                baseStr = metadataMatch[1];
-                metadataStr = metadataMatch[2];
-            }
-            // Check for display name alias
-            const aliasMatch = baseStr.match(/^(.*?)\s+as\s+(.*)$/);
-            if (aliasMatch) {
-                group.propertyName = aliasMatch[1].trim();
-                group.displayName = aliasMatch[2].trim();
+    getGrantedPolicy$(key) {
+        return this.getStream().pipe(map$1(grantedPolicies => this.isPolicyGranted(key, grantedPolicies)));
+    }
+    isGrantedAsync(permissionName) {
+        if (!permissionName)
+            return true;
+        return this.getGrantedPolicy$(permissionName);
+    }
+    isGranted(permissionName) {
+        if (!permissionName)
+            return true;
+        return this.getGrantedPolicy(permissionName);
+    }
+    getGrantedPolicy(key) {
+        const policies = this.getSnapshot();
+        return this.isPolicyGranted(key, policies);
+    }
+    getStream() {
+        return this.configState.getAll$().pipe(map$1(this.mapToPolicies));
+    }
+    getSnapshot() {
+        return this.mapToPolicies(this.configState.getAll());
+    }
+    mapToPolicies(applicationConfiguration) {
+        return applicationConfiguration?.auth?.grantedPolicies || {};
+    }
+    getPolicy(key, grantedPolicies) {
+        return grantedPolicies[key] || false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: PermissionCheckerService, deps: [{ token: ConfigStateService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: PermissionCheckerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: PermissionCheckerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: ConfigStateService }] });
+
+const ngxPermissionsGuard = (route, state) => {
+    const guard = inject(NgxPermissionsGuard);
+    if (state instanceof RouterStateSnapshot) {
+        return guard.hasPermissions(route, state);
+    }
+    return guard.hasPermissions(route);
+};
+class NgxPermissionsGuard {
+    permissions;
+    router;
+    constructor(permissions, router) {
+        this.permissions = permissions;
+        this.router = router;
+    }
+    canActivate(route, state) {
+        return this.hasPermissions(route, state);
+    }
+    canActivateChild(route, state) {
+        return this.hasPermissions(route, state);
+    }
+    canLoad(route) {
+        return this.hasPermissions(route);
+    }
+    canMatch(route) {
+        return this.hasPermissions(route);
+    }
+    async hasPermissions(route, state) {
+        const data = route.data?.['permissions'];
+        const only = [];
+        const except = [];
+        if (data?.only) {
+            if (isFunction(data.only)) {
+                const result = data.only(route, state);
+                only.push(...transformStringToArray(result));
             }
             else {
-                group.propertyName = baseStr.trim();
+                only.push(...transformStringToArray(data.only));
             }
-            // Parse metadata
-            if (metadataStr) {
-                const metadataParts = metadataStr.split(';');
-                metadataParts.forEach(part => {
-                    const [key, value] = part.split(':');
-                    switch (key) {
-                        case 'showTotal':
-                            group.showTotal = value.toLowerCase() === 'true';
-                            break;
-                        case 'totalBg':
-                            group.totalBackground = value;
-                            break;
-                        case 'headerBg':
-                            group.groupHeaderBackground = value;
-                            break;
-                    }
-                });
+        }
+        if (data?.except) {
+            if (isFunction(data.except)) {
+                const result = data.except(route, state);
+                except.push(...transformStringToArray(result));
             }
-            return group;
-        });
-    }
-    static parseSelect(selectString, params) {
-        const decodedString = decodeURIComponent(selectString);
-        const items = decodedString.split(',');
-        params.select = items.map((itemStr, index) => {
-            const item = {
-                propertyName: '',
-                isVisible: true,
-                order: index
-            };
-            // Check for metadata in parentheses
-            const metadataMatch = itemStr.match(/^(.*?)\((.*)\)$/);
-            let baseStr = itemStr;
-            let metadataStr = '';
-            if (metadataMatch) {
-                baseStr = metadataMatch[1];
-                metadataStr = metadataMatch[2];
+            else {
+                except.push(...transformStringToArray(data.except));
             }
-            // Check for display name alias and aggregate function
-            const aliasMatch = baseStr.match(/^(.*?)(?:\s+as\s+(.*?))?(?:\s+with\s+(\w+))?$/);
-            if (aliasMatch) {
-                item.propertyName = aliasMatch[1].trim();
-                if (aliasMatch[2]) {
-                    item.displayName = aliasMatch[2].trim();
-                }
-                if (aliasMatch[3]) {
-                    item.aggregateFunction = aliasMatch[3].trim();
+        }
+        const permissions = {
+            only,
+            except,
+            redirectTo: data?.redirectTo
+        };
+        // --- rest of the guard logic ---
+        // EXCEPT check
+        if (permissions.except?.length) {
+            for (const perm of permissions.except) {
+                if (await this.permissions.isGranted(perm)) {
+                    this.handleRedirect(permissions, perm, route, state);
+                    return false;
                 }
             }
-            else {
-                item.propertyName = baseStr.trim();
-            }
-            // Parse metadata
-            if (metadataStr) {
-                const metadataParts = metadataStr.split(';');
-                metadataParts.forEach(part => {
-                    const [key, value] = part.split(':');
-                    if (key === 'visible') {
-                        item.isVisible = value.toLowerCase() === 'true';
-                    }
-                });
+        }
+        // ONLY check
+        if (permissions.only?.length) {
+            for (const perm of permissions.only) {
+                if (await this.permissions.isGrantedAsync(perm)) {
+                    return true;
+                }
             }
-            return item;
-        });
+            this.handleRedirect(permissions, permissions.only[0], route, state);
+            return false;
+        }
+        return true;
     }
-    static parseAggregate(aggregateString, params) {
-        const decodedString = decodeURIComponent(aggregateString);
-        const aggregates = decodedString.split(',');
-        params.aggregates = aggregates.map(aggStr => {
-            const agg = {
-                propertyName: '',
-                aggregateFunction: ''
-            };
-            // Match pattern: function(property) as alias
-            const match = aggStr.match(/^(\w+)\((\w+)\)(?:\s+as\s+(\w+))?$/);
-            if (match) {
-                agg.aggregateFunction = match[1];
-                agg.propertyName = match[2];
-                if (match[3]) {
-                    agg.alias = match[3];
+    handleRedirect(permissions, failedPermission, route, state) {
+        const redirectTo = permissions.redirectTo;
+        if (!redirectTo)
+            return;
+        // If redirectTo is a function
+        const resolvedRedirect = isFunction(redirectTo)
+            ? redirectTo(failedPermission, route, state)
+            : redirectTo;
+        if (typeof resolvedRedirect === 'string') {
+            this.router.navigate([resolvedRedirect]); // wrap string in array
+        }
+        else if (Array.isArray(resolvedRedirect)) {
+            this.router.navigate(resolvedRedirect); // array is fine
+        }
+        else if (isPlainObject(resolvedRedirect)) {
+            // Object: check for failedPermission key first
+            const target = resolvedRedirect[failedPermission] ?? resolvedRedirect[DEFAULT_REDIRECT_KEY];
+            if (target) {
+                if (typeof target === 'string') {
+                    this.router.navigate([target]);
+                }
+                else if (Array.isArray(target)) {
+                    this.router.navigate(target);
+                }
+                else if (isFunction(target)) {
+                    this.router.navigate([target(failedPermission, route, state)]);
                 }
             }
-            return agg;
-        });
-    }
-    // Helper method to convert QueryParameters to ODataQueryParameters (C# equivalent)
-    static toODataQueryParameters(params) {
-        return {
-            Filters: params.filters.map(group => ({
-                LogicalOperator: group.logicalOperator,
-                GroupLogicalOperator: group.groupLogicalOperator,
-                Conditions: group.conditions.map(cond => ({
-                    Field: cond.field,
-                    Operator: cond.operator,
-                    Value: cond.value
-                }))
-            })),
-            OrderBy: params.orderBy?.map(order => ({
-                Field: order.field,
-                Direction: order.direction
-            })) || [],
-            GroupBy: params.groupBy?.map(group => ({
-                PropertyName: group.propertyName,
-                DisplayName: group.displayName,
-                ShowTotal: group.showTotal ?? true,
-                TotalBackground: group.totalBackground,
-                GroupHeaderBackground: group.groupHeaderBackground,
-                Order: group.order
-            })) || [],
-            Select: params.select?.map(sel => ({
-                PropertyName: sel.propertyName,
-                DisplayName: sel.displayName,
-                AggregateFunction: sel.aggregateFunction,
-                IsVisible: sel.isVisible ?? true,
-                Order: sel.order
-            })) || [],
-            Aggregates: params.aggregates?.map(agg => ({
-                PropertyName: agg.propertyName,
-                AggregateFunction: agg.aggregateFunction,
-                Alias: agg.alias
-            })) || [],
-            Top: params.top,
-            Skip: params.skip,
-            Expand: params.expand,
-            IncludeCount: params.includeCount
-        };
-    }
-    // Helper method to create query parameters from UI model
-    static fromUIModel(model) {
-        const params = {
-            filters: model.advancedFilters || [],
-            orderBy: model.sorting || [],
-            groupBy: model.grouping || [],
-            select: model.columns || [],
-            aggregates: model.aggregates || [],
-            top: model.pagination?.top,
-            skip: model.pagination?.skip,
-            expand: model.expand,
-            includeCount: model.pagination?.includeCount
-        };
-        return params;
+        }
+        else {
+            console.warn('Unknown redirect type', resolvedRedirect);
+        }
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: NgxPermissionsGuard, deps: [{ token: PermissionCheckerService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: NgxPermissionsGuard, providedIn: 'root' });
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: NgxPermissionsGuard, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: PermissionCheckerService }, { type: i2.Router }] });
 
-class SessionStateService {
-    configState;
-    localStorageService;
-    store = new InternalStore({});
-    document = inject(DOCUMENT);
-    updateLocalStorage = () => {
-        this.localStorageService.set('abpSession', JSON.stringify(this.store.state), { expires: new Date(new Date().getTime() + 365 * 86400000), path: '/' });
-    };
-    constructor(configState, localStorageService) {
-        this.configState = configState;
-        this.localStorageService = localStorageService;
-        this.init();
-        this.setInitialLanguage();
-    }
-    init() {
-        const session = this.localStorageService.get('abpSession');
-        if (session) {
-            this.store.set(JSON.parse(session));
+// logger.interface.ts
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["OFF"] = 4] = "OFF";
+})(LogLevel || (LogLevel = {}));
+
+// logger.service.ts
+// Remove the separate LoggerConfig interface since we're using EnvironmentConfig
+// and extend EnvironmentConfig to include logger-specific properties
+class LoggerService {
+    level = LogLevel.DEBUG;
+    enableConsole = true;
+    prefix = '[App]';
+    timestamp = true;
+    environmentService = inject(EnvironmentService);
+    environment = this.environmentService?.getEnvironment();
+    constructor() {
+        // Use environment configuration if provided
+        if (this.environment) {
+            this.configureFromEnvironment(this.environment);
+        }
+        // Fallback: In production, default to WARN level
+        if (typeof window !== 'undefined' && window.location.hostname !== 'localhost') {
+            this.level = LogLevel.WARN;
+            this.enableConsole = false;
         }
-        this.store.sliceUpdate(state => state).subscribe(this.updateLocalStorage);
-    }
-    setInitialLanguage() {
-        const appLanguage = this.getLanguage();
-        this.configState
-            .getDeep$('localization.currentCulture.cultureName')
-            .pipe(filter(cultureName => !!cultureName), take(1))
-            .subscribe(lang => {
-            if (lang.includes(';')) {
-                lang = lang.split(';')[0];
-            }
-            this.setLanguage(lang);
-        });
     }
-    onLanguageChange$() {
-        return this.store.sliceUpdate(state => state.language);
+    configureFromEnvironment(env) {
+        // Map string log levels from environment to LogLevel enum
+        this.level = this.mapLogLevel(env.logLevel);
+        // Use production flag to determine console logging
+        this.enableConsole = !env.production;
+        // Set prefix from environment if available
+        this.prefix = `[${env['appName'] || 'App'}]`;
+        // Enable timestamp in development, disable in production for performance
+        this.timestamp = !env.production;
     }
-    onTenantChange$() {
-        return this.store.sliceUpdate(state => state.tenant);
+    mapLogLevel(level) {
+        switch (level) {
+            case 'debug': return LogLevel.DEBUG;
+            case 'info': return LogLevel.INFO;
+            case 'warn': return LogLevel.WARN;
+            case 'error': return LogLevel.ERROR;
+            case 'off': return LogLevel.OFF;
+            default: return LogLevel.WARN;
+        }
     }
-    getLanguage() {
-        return this.store.state.language;
+    debug(message, ...args) {
+        if (this.shouldLog(LogLevel.DEBUG)) {
+            this.log('DEBUG', message, args, 'color: blue');
+        }
     }
-    getLanguage$() {
-        return this.store.sliceState(state => state.language);
+    info(message, ...args) {
+        if (this.shouldLog(LogLevel.INFO)) {
+            this.log('INFO', message, args, 'color: green');
+        }
     }
-    getTenant() {
-        return this.store.state.tenant;
+    warn(message, ...args) {
+        if (this.shouldLog(LogLevel.WARN)) {
+            this.log('WARN', message, args, 'color: orange');
+        }
     }
-    getTenant$() {
-        return this.store.sliceState(state => state.tenant);
+    error(message, ...args) {
+        if (this.shouldLog(LogLevel.ERROR)) {
+            this.log('ERROR', message, args, 'color: red');
+            // Send to external services only for errors in production
+            if (this.environment?.production) {
+                this.sendToExternalService('ERROR', message, args);
+            }
+        }
     }
-    setTenant(tenant) {
-        if (compare(tenant, this.store.state.tenant))
-            return;
-        this.store.set({ ...this.store.state, tenant });
+    setLogLevel(level) {
+        this.level = level;
     }
-    setState(session) {
-        if (compare(session, this.store.state))
-            return;
-        this.store.set({ ...this.store.state, ...session });
+    shouldLog(level) {
+        return level >= this.level && this.enableConsole;
     }
-    setLanguage(language) {
-        const currentLanguage = this.store.state.language;
-        if (language !== currentLanguage) {
-            this.store.patch({ language });
+    log(level, message, args, style) {
+        if (!this.enableConsole)
+            return;
+        const timestamp = this.timestamp ? new Date().toISOString() : '';
+        const formattedPrefix = this.prefix ? `${this.prefix}` : '';
+        const logMessage = `${timestamp} ${formattedPrefix} [${level}] ${message}`;
+        if (args.length > 0) {
+            console.log(`%c${logMessage}`, style, ...args);
         }
-        const currentAttribute = this.document.documentElement.getAttribute('lang');
-        if (language !== currentAttribute) {
-            this.document.documentElement.setAttribute('lang', language);
+        else {
+            console.log(`%c${logMessage}`, style);
         }
     }
-    get application() {
-        return this.store.state.application;
+    sendToExternalService(level, message, args) {
+        // Integrate with external logging services from environment
+        try {
+            const sentryUrl = this.environment?.externalServices?.['sentry'];
+            const logRocketUrl = this.environment?.externalServices?.['logRocket'];
+            // Example: Send to configured external services
+            if (sentryUrl) {
+                // this.sendToSentry(level, message, args);
+            }
+            if (logRocketUrl) {
+                // this.sendToLogRocket(level, message, args);
+            }
+            // Send to backend if apiUrl is available
+            if (this.environment?.apis.default.url) {
+                // this.http.post(`${this.environment.apiUrl}/logs`, {
+                //   level, message, args, timestamp: new Date()
+                // }).subscribe();
+            }
+        }
+        catch (error) {
+            // Don't use this.error here to avoid infinite loops
+            console.error('Failed to send log to external service:', error);
+        }
     }
-    get user() {
-        return this.store.state.user;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LoggerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LoggerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LoggerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+class IdParserService {
+    /**
+     * Extract IDs from a model based on comma-separated field names.
+     * Example: "id,biId" => [model.id, model.biId]
+     */
+    parseIds(model, idField) {
+        if (!idField)
+            return null;
+        const fields = idField.split(',').map(f => f.trim()).filter(Boolean);
+        if (fields.length === 1) {
+            return model[fields[0]];
+        }
+        return fields.map(f => model[f]);
     }
-    get userId() {
-        return this.user ? this.user.id : 0;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: IdParserService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: IdParserService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: IdParserService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class QueryParser {
+    static parse(queryString) {
+        const params = {
+            filters: [],
+            orderBy: [],
+            groupBy: [],
+            select: [],
+            aggregates: []
+        };
+        if (!queryString)
+            return params;
+        const queryParts = queryString.split('&');
+        for (const part of queryParts) {
+            if (part.startsWith('$filter=')) {
+                this.parseFilter(part.substring('$filter='.length), params);
+            }
+            else if (part.startsWith('$orderby=')) {
+                this.parseOrderBy(part.substring('$orderby='.length), params);
+            }
+            else if (part.startsWith('$groupby=')) {
+                this.parseGroupBy(part.substring('$groupby='.length), params);
+            }
+            else if (part.startsWith('$select=')) {
+                this.parseSelect(part.substring('$select='.length), params);
+            }
+            else if (part.startsWith('$aggregate=')) {
+                this.parseAggregate(part.substring('$aggregate='.length), params);
+            }
+            else if (part.startsWith('$top=')) {
+                params.top = Number(part.substring('$top='.length));
+            }
+            else if (part.startsWith('$skip=')) {
+                params.skip = Number(part.substring('$skip='.length));
+            }
+            else if (part.startsWith('$expand=')) {
+                params.expand = part.substring('$expand='.length).split(',').map(f => f.trim());
+            }
+            else if (part.startsWith('$count=')) {
+                params.includeCount = part.substring('$count='.length).toLowerCase() === 'true';
+            }
+        }
+        return params;
     }
-    get tenant() {
-        return this.store.state.tenant;
+    static toString(params) {
+        const parts = [];
+        if (params.filters?.length) {
+            const filterStr = this.buildFilterString(params.filters);
+            parts.push(`$filter=${encodeURIComponent(filterStr)}`);
+        }
+        if (params.orderBy?.length) {
+            const orderByStr = params.orderBy.map(o => `${o.field} ${o.direction}`).join(',');
+            parts.push(`$orderby=${encodeURIComponent(orderByStr)}`);
+        }
+        if (params.groupBy?.length) {
+            const groupByStr = this.buildGroupByString(params.groupBy);
+            parts.push(`$groupby=${encodeURIComponent(groupByStr)}`);
+        }
+        if (params.select?.length) {
+            const selectStr = this.buildSelectString(params.select);
+            parts.push(`$select=${encodeURIComponent(selectStr)}`);
+        }
+        if (params.aggregates?.length) {
+            const aggregateStr = this.buildAggregateString(params.aggregates);
+            parts.push(`$aggregate=${encodeURIComponent(aggregateStr)}`);
+        }
+        if (params.top !== undefined) {
+            parts.push(`$top=${params.top}`);
+        }
+        if (params.skip !== undefined) {
+            parts.push(`$skip=${params.skip}`);
+        }
+        if (params.expand?.length) {
+            parts.push(`$expand=${encodeURIComponent(params.expand.join(','))}`);
+        }
+        if (params.includeCount !== undefined) {
+            parts.push(`$count=${params.includeCount}`);
+        }
+        return parts.join('&');
     }
-    get branch() {
-        return this.store.state.branch;
+    static buildFilterString(filters) {
+        return filters.map((group, index) => {
+            const groupStr = group.conditions
+                .map(condition => {
+                let val = condition.value;
+                if (typeof val === 'string') {
+                    val = `'${val.replace(/'/g, "''")}'`;
+                }
+                else if (typeof val === 'boolean') {
+                    val = val ? 'true' : 'false';
+                }
+                return `${condition.field} ${condition.operator} ${val}`;
+            })
+                .join(` ${group.logicalOperator} `);
+            // For the first group, no groupLogicalOperator is needed
+            if (index === 0) {
+                return group.conditions.length > 1 ? `(${groupStr})` : groupStr;
+            }
+            else {
+                const joinOp = group.groupLogicalOperator || 'and';
+                return group.conditions.length > 1 ? `${joinOp} (${groupStr})` : `${joinOp} ${groupStr}`;
+            }
+        }).join(' ');
     }
-    /* get branchName(): BranchLoginInfoDto {
-        return this._branch ? this.branch.Name : '';
-
-    } */
-    get tenancyName() {
-        return this.store.state.tenant ? this.tenant?.tenancyName : '';
+    static buildGroupByString(groupBy) {
+        return groupBy
+            .sort((a, b) => (a.order || 0) - (b.order || 0))
+            .map(group => {
+            let groupStr = group.propertyName;
+            // Add display name if provided
+            if (group.displayName) {
+                groupStr += ` as ${group.displayName}`;
+            }
+            // Add metadata for UI
+            const metadata = [];
+            if (group.showTotal !== undefined) {
+                metadata.push(`showTotal:${group.showTotal}`);
+            }
+            if (group.totalBackground) {
+                metadata.push(`totalBg:${group.totalBackground}`);
+            }
+            if (group.groupHeaderBackground) {
+                metadata.push(`headerBg:${group.groupHeaderBackground}`);
+            }
+            if (metadata.length > 0) {
+                groupStr += `(${metadata.join(';')})`;
+            }
+            return groupStr;
+        })
+            .join(',');
     }
-    get branchId() {
-        // return this.branch ? this.branch.id : this.configState.Session?.branchId ? this.configState.Session.branchId:null;
-        return this.branch ? this.branch.id : 0;
+    static buildSelectString(select) {
+        return select
+            .sort((a, b) => (a.order || 0) - (b.order || 0))
+            .map(item => {
+            let selectStr = item.propertyName;
+            // Add display name if provided
+            if (item.displayName) {
+                selectStr += ` as ${item.displayName}`;
+            }
+            // Add aggregate function if provided
+            if (item.aggregateFunction) {
+                selectStr += ` with ${item.aggregateFunction}`;
+            }
+            // Add visibility metadata
+            const metadata = [];
+            if (item.isVisible !== undefined) {
+                metadata.push(`visible:${item.isVisible}`);
+            }
+            if (metadata.length > 0) {
+                selectStr += `(${metadata.join(';')})`;
+            }
+            return selectStr;
+        })
+            .join(',');
     }
-    get tenantId() {
-        return this.tenant ? this.tenant.id : 0;
+    static buildAggregateString(aggregates) {
+        return aggregates
+            .map(agg => {
+            let aggStr = `${agg.aggregateFunction}(${agg.propertyName})`;
+            if (agg.alias) {
+                aggStr += ` as ${agg.alias}`;
+            }
+            return aggStr;
+        })
+            .join(',');
     }
-    getShownLoginName() {
-        const userName = this.store.state.user?.userName ?? '';
-        if (!this.multiTenancySide) {
-            return userName;
+    static parseFilter(filterString, params) {
+        const decodedString = decodeURIComponent(filterString);
+        const groups = [];
+        // Split by top-level AND/OR operators
+        const topLevelPattern = /(?:^|\s)(and|or)\s+(?=(?:[^()]*\([^()]*\))*[^()]*$)/gi;
+        const segments = [];
+        let lastIndex = 0;
+        let match;
+        while ((match = topLevelPattern.exec(decodedString)) !== null) {
+            const operator = match[1];
+            const segment = decodedString.substring(lastIndex, match.index).trim();
+            if (segment) {
+                segments.push({ condition: segment, operator });
+            }
+            lastIndex = match.index + match[0].length;
         }
-        return (this.store.state.tenant ? this.store.state.tenant.tenancyName : '.') + '\\' + userName;
-    }
-    changeTenantIfNeeded(tenantId) {
-        if (this.isCurrentTenant(tenantId)) {
-            return false;
+        // Add the last segment
+        const lastSegment = decodedString.substring(lastIndex).trim();
+        if (lastSegment) {
+            segments.push({ condition: lastSegment, operator: undefined });
         }
-        // this.configState.SetTenantIdCookie(tenantId);
-        location.reload();
-        return true;
+        // Parse each segment
+        segments.forEach((segment, index) => {
+            let conditions = [];
+            // Check if it's a group with parentheses
+            if (segment.condition.startsWith('(') && segment.condition.endsWith(')')) {
+                const innerCondition = segment.condition.slice(1, -1).trim();
+                conditions = this.parseConditions(innerCondition);
+            }
+            else {
+                // Individual condition
+                conditions = this.parseConditions(segment.condition);
+            }
+            if (conditions.length > 0) {
+                const group = {
+                    logicalOperator: 'and',
+                    conditions: conditions
+                };
+                // For groups after the first, set the groupLogicalOperator
+                if (index > 0) {
+                    group.groupLogicalOperator = segment.operator?.toLowerCase() || 'and';
+                }
+                // Detect the logical operator used within the group
+                if (conditions.length === 1 && segment.condition.includes(' or ')) {
+                    group.logicalOperator = 'or';
+                }
+                else if (conditions.length > 1) {
+                    group.logicalOperator = segment.condition.toLowerCase().includes(' or ') ? 'or' : 'and';
+                }
+                groups.push(group);
+            }
+        });
+        params.filters = groups;
     }
-    isCurrentTenant(tenantId) {
-        let isTenant = tenantId ?? 0 > 0;
-        if (!isTenant && !this.tenant) { // this is host
-            return true;
-        }
-        if (!tenantId && this.tenant) {
-            return false;
-        }
-        else if (tenantId && (!this.tenant || this.tenant.id !== tenantId)) {
-            return false;
+    static parseConditions(conditionString) {
+        const conditions = [];
+        // Enhanced pattern to handle more operators and complex values
+        const pattern = /(\w+(?:\.\w+)*)\s+(eq|ne|gt|ge|lt|le|contains|startswith|endswith|in|notin)\s+('[^']*'|\[[^\]]*\]|\d+|true|false|null)/gi;
+        let match;
+        while ((match = pattern.exec(conditionString)) !== null) {
+            const [, field, operator, rawValue] = match;
+            let value = rawValue.trim();
+            if (rawValue.startsWith("'") && rawValue.endsWith("'")) {
+                value = rawValue.slice(1, -1).replace(/''/g, "'");
+            }
+            else if (rawValue.startsWith('[') && rawValue.endsWith(']')) {
+                // Handle array values for IN/NOT IN operators
+                value = rawValue.slice(1, -1).split(',').map(v => {
+                    const trimmed = v.trim().replace(/^'|'$/g, '');
+                    return isNaN(Number(trimmed)) ? trimmed : Number(trimmed);
+                });
+            }
+            else if (!isNaN(Number(rawValue))) {
+                value = Number(rawValue);
+            }
+            else if (rawValue.toLowerCase() === 'true') {
+                value = true;
+            }
+            else if (rawValue.toLowerCase() === 'false') {
+                value = false;
+            }
+            else if (rawValue.toLowerCase() === 'null') {
+                value = null;
+            }
+            conditions.push({
+                field: field.trim(),
+                operator: operator.trim().toLowerCase(),
+                value
+            });
         }
-        return true;
-    }
-    get impersonatorUser() {
-        return this.store.state.impersonatorUser;
-    }
-    get impersonatorUserId() {
-        return this.impersonatorUser ? this.impersonatorUser.id : 0;
-    }
-    get impersonatorTenant() {
-        return this.store.state.impersonatorTenant;
-    }
-    get impersonatorTenancyName() {
-        return this.impersonatorTenant ? this.impersonatorTenant?.tenancyName ?? '' : '';
-    }
-    get impersonatorTenantId() {
-        return this.impersonatorTenant ? this.impersonatorTenant.id : 0;
-    }
-    get multiTenancySide() {
-        // return this.configState.session?.multiTenancySide;
-        return 0;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SessionStateService, deps: [{ token: ConfigStateService }, { token: SsrCookieService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SessionStateService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: SessionStateService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: ConfigStateService }, { type: SsrCookieService }] });
-
-class LocalizationService {
-    sessionState;
-    injector;
-    configState;
-    latestLang = 'ar';
-    _languageChange$ = new Subject();
-    uiLocalizations$ = new BehaviorSubject(new Map());
-    localizations$ = new BehaviorSubject(new Map());
-    /**
-     * Returns currently selected language
-     * Even though this looks like it's redundant to return the same value as `getLanguage()`,
-     * it's actually not. This could be invoked any time, and the latestLang could be different from the
-     * sessionState.getLanguage() value.
-     */
-    get currentLanguage() {
-        return this.latestLang || this.sessionState.getLanguage();
-    }
-    get currentLang() {
-        return this.latestLang || this.sessionState.getLanguage();
-    }
-    get currentLang$() {
-        return this.sessionState.getLanguage$();
+        return conditions;
     }
-    get languageChange$() {
-        return this._languageChange$.asObservable();
+    static parseOrderBy(orderByString, params) {
+        const decodedString = decodeURIComponent(orderByString);
+        const clauses = decodedString.split(',');
+        for (const clause of clauses) {
+            const parts = clause.trim().split(/\s+/);
+            const field = parts[0];
+            const direction = parts[1]?.toLowerCase() || 'asc';
+            params.orderBy?.push({
+                field,
+                direction
+            });
+        }
     }
-    constructor(sessionState, injector, otherInstance, configState) {
-        this.sessionState = sessionState;
-        this.injector = injector;
-        this.configState = configState;
-        if (otherInstance)
-            throw new Error('LocalizationService should have only one instance.');
-        this.listenToSetLanguage();
-        this.initLocalizationValues();
-        this.latestLang = this.sessionState.getLanguage();
+    static parseGroupBy(groupByString, params) {
+        const decodedString = decodeURIComponent(groupByString);
+        const groups = decodedString.split(',');
+        params.groupBy = groups.map((groupStr, index) => {
+            const group = {
+                propertyName: '',
+                order: index
+            };
+            // Check for metadata in parentheses
+            const metadataMatch = groupStr.match(/^(.*?)\((.*)\)$/);
+            let baseStr = groupStr;
+            let metadataStr = '';
+            if (metadataMatch) {
+                baseStr = metadataMatch[1];
+                metadataStr = metadataMatch[2];
+            }
+            // Check for display name alias
+            const aliasMatch = baseStr.match(/^(.*?)\s+as\s+(.*)$/);
+            if (aliasMatch) {
+                group.propertyName = aliasMatch[1].trim();
+                group.displayName = aliasMatch[2].trim();
+            }
+            else {
+                group.propertyName = baseStr.trim();
+            }
+            // Parse metadata
+            if (metadataStr) {
+                const metadataParts = metadataStr.split(';');
+                metadataParts.forEach(part => {
+                    const [key, value] = part.split(':');
+                    switch (key) {
+                        case 'showTotal':
+                            group.showTotal = value.toLowerCase() === 'true';
+                            break;
+                        case 'totalBg':
+                            group.totalBackground = value;
+                            break;
+                        case 'headerBg':
+                            group.groupHeaderBackground = value;
+                            break;
+                    }
+                });
+            }
+            return group;
+        });
     }
-    initLocalizationValues() {
-        localizations$.subscribe(val => this.addLocalization(val));
-        const legacyResources$ = this.configState.getDeep$('localization.values');
-        const remoteLocalizations$ = this.configState.getDeep$('localization.resources');
-        const currentLanguage$ = this.sessionState.getLanguage$();
-        const uiLocalizations$ = combineLatest([currentLanguage$, this.uiLocalizations$]).pipe(map(([currentLang, localizations]) => localizations.get(currentLang)));
-        combineLatest([legacyResources$, remoteLocalizations$, uiLocalizations$])
-            .pipe(map(([legacy, resource, local]) => {
-            if (!resource) {
-                return null;
+    static parseSelect(selectString, params) {
+        const decodedString = decodeURIComponent(selectString);
+        const items = decodedString.split(',');
+        params.select = items.map((itemStr, index) => {
+            const item = {
+                propertyName: '',
+                isVisible: true,
+                order: index
+            };
+            // Check for metadata in parentheses
+            const metadataMatch = itemStr.match(/^(.*?)\((.*)\)$/);
+            let baseStr = itemStr;
+            let metadataStr = '';
+            if (metadataMatch) {
+                baseStr = metadataMatch[1];
+                metadataStr = metadataMatch[2];
             }
-            const remote = combineLegacyandNewResources(legacy || {}, resource);
-            if (remote) {
-                if (!local) {
-                    local = new Map();
+            // Check for display name alias and aggregate function
+            const aliasMatch = baseStr.match(/^(.*?)(?:\s+as\s+(.*?))?(?:\s+with\s+(\w+))?$/);
+            if (aliasMatch) {
+                item.propertyName = aliasMatch[1].trim();
+                if (aliasMatch[2]) {
+                    item.displayName = aliasMatch[2].trim();
                 }
-                Object.entries(remote).forEach(entry => {
-                    const resourceName = entry[0];
-                    const remoteTexts = entry[1];
-                    let resource = local?.get(resourceName) || {};
-                    resource = { ...resource, ...remoteTexts };
-                    local?.set(resourceName, resource);
+                if (aliasMatch[3]) {
+                    item.aggregateFunction = aliasMatch[3].trim();
+                }
+            }
+            else {
+                item.propertyName = baseStr.trim();
+            }
+            // Parse metadata
+            if (metadataStr) {
+                const metadataParts = metadataStr.split(';');
+                metadataParts.forEach(part => {
+                    const [key, value] = part.split(':');
+                    if (key === 'visible') {
+                        item.isVisible = value.toLowerCase() === 'true';
+                    }
                 });
             }
-            return local;
-        }), filter(Boolean))
-            .subscribe(val => this.localizations$.next(val));
-    }
-    addLocalization(localizations) {
-        if (!localizations)
-            return;
-        const localizationMap = this.uiLocalizations$.value;
-        localizations.forEach(loc => {
-            const cultureMap = localizationMap.get(loc.culture) || new Map();
-            loc.resources.forEach(res => {
-                let resource = cultureMap.get(res.resourceName) || {};
-                resource = { ...resource, ...res.texts };
-                cultureMap.set(res.resourceName, resource);
-            });
-            localizationMap.set(loc.culture, cultureMap);
+            return item;
         });
-        this.uiLocalizations$.next(localizationMap);
-    }
-    listenToSetLanguage() {
-        this.sessionState
-            .onLanguageChange$()
-            .pipe(filter(lang => this.configState.getDeep('localization.currentCulture.cultureName') !== lang), switchMap((lang) => this.configState.refreshLocalization(lang).pipe(map(() => lang))), filter(Boolean), switchMap((lang) => from(this.registerLocale(lang).then(() => lang))))
-            .subscribe((lang) => this._languageChange$.next(lang));
     }
-    registerLocale(locale) {
-        const { registerLocaleFn } = this.injector.get(CORE_OPTIONS);
-        return registerLocaleFn(locale).then(module => {
-            if (module?.default)
-                registerLocaleData(module.default);
-            this.latestLang = locale;
+    static parseAggregate(aggregateString, params) {
+        const decodedString = decodeURIComponent(aggregateString);
+        const aggregates = decodedString.split(',');
+        params.aggregates = aggregates.map(aggStr => {
+            const agg = {
+                propertyName: '',
+                aggregateFunction: ''
+            };
+            // Match pattern: function(property) as alias
+            const match = aggStr.match(/^(\w+)\((\w+)\)(?:\s+as\s+(\w+))?$/);
+            if (match) {
+                agg.aggregateFunction = match[1];
+                agg.propertyName = match[2];
+                if (match[3]) {
+                    agg.alias = match[3];
+                }
+            }
+            return agg;
         });
     }
-    /**
-     * Returns an observable localized text with the given interpolation parameters in current language.
-     * @param key Localizaton key to replace with localized text
-     * @param interpolateParams Values to interpolate
-     */
-    get(key, ...interpolateParams) {
-        return this.configState
-            .getAll$()
-            .pipe(map(state => this.getLocalization(state, key, ...interpolateParams)));
-    }
-    getResource(resourceName) {
-        return this.localizations$.value.get(resourceName);
-    }
-    getResource$(resourceName) {
-        return this.localizations$.pipe(map(res => res.get(resourceName)));
-    }
-    /**
-     * Returns localized text with the given interpolation parameters in current language.
-     * @param key Localization key to replace with localized text
-     * @param interpolateParams Values to intepolate.
-     */
-    instant(key, ...interpolateParams) {
-        return this.getLocalization(this.configState.getAll(), key, ...interpolateParams);
-    }
-    localize(resourceName, key, defaultValue) {
-        return this.configState.getOne$('localization').pipe(map(createLocalizer), map((localize) => localize(resourceName, key, defaultValue)));
-    }
-    get defaultResourceName() {
-        return this.configState.getAll().localization ? this.configState.getAll().localization.defaultResourceName : 'FrameworkLocalization';
-    }
-    l(key) {
-        const localization = this.configState.getOne('localization');
-        return createLocalizer(localization)(this.defaultResourceName ?? '', key, key);
-    }
-    localizeSync(resourceName, key, defaultValue) {
-        const localization = this.configState.getOne('localization');
-        return createLocalizer(localization)(resourceName, key, defaultValue);
-    }
-    localizeWithFallback(resourceNames, keys, defaultValue) {
-        return this.configState.getOne$('localization').pipe(map(createLocalizerWithFallback), map((localizeWithFallback) => localizeWithFallback(resourceNames, keys, defaultValue)));
-    }
-    localizeWithFallbackSync(resourceNames, keys, defaultValue) {
-        const localization = this.configState.getOne('localization');
-        return createLocalizerWithFallback(localization)(resourceNames, keys, defaultValue);
-    }
-    getLocalization(state, key, ...interpolateParams) {
-        let defaultValue = '';
-        if (!key) {
-            return defaultValue;
-        }
-        if (typeof key !== 'string') {
-            defaultValue = key.defaultValue;
-            key = key.key;
-        }
-        const keys = key.split('::');
-        const warn = (message) => {
-            if (isDevMode())
-                console.warn(message);
+    // Helper method to convert QueryParameters to ODataQueryParameters (C# equivalent)
+    static toODataQueryParameters(params) {
+        return {
+            Filters: params.filters.map(group => ({
+                LogicalOperator: group.logicalOperator,
+                GroupLogicalOperator: group.groupLogicalOperator,
+                Conditions: group.conditions.map(cond => ({
+                    Field: cond.field,
+                    Operator: cond.operator,
+                    Value: cond.value
+                }))
+            })),
+            OrderBy: params.orderBy?.map(order => ({
+                Field: order.field,
+                Direction: order.direction
+            })) || [],
+            GroupBy: params.groupBy?.map(group => ({
+                PropertyName: group.propertyName,
+                DisplayName: group.displayName,
+                ShowTotal: group.showTotal ?? true,
+                TotalBackground: group.totalBackground,
+                GroupHeaderBackground: group.groupHeaderBackground,
+                Order: group.order
+            })) || [],
+            Select: params.select?.map(sel => ({
+                PropertyName: sel.propertyName,
+                DisplayName: sel.displayName,
+                AggregateFunction: sel.aggregateFunction,
+                IsVisible: sel.isVisible ?? true,
+                Order: sel.order
+            })) || [],
+            Aggregates: params.aggregates?.map(agg => ({
+                PropertyName: agg.propertyName,
+                AggregateFunction: agg.aggregateFunction,
+                Alias: agg.alias
+            })) || [],
+            Top: params.top,
+            Skip: params.skip,
+            Expand: params.expand,
+            IncludeCount: params.includeCount
         };
-        if (keys.length < 2) {
-            warn('The localization source separator (::) not found.');
-            return defaultValue || key;
-        }
-        if (!state.localization)
-            return defaultValue || keys[1];
-        const sourceName = keys[0] || state.localization.defaultResourceName;
-        const sourceKey = keys[1];
-        if (sourceName === '_') {
-            return defaultValue || sourceKey;
-        }
-        if (!sourceName) {
-            warn('Localization source name is not specified and the defaultResourceName was not defined!');
-            return defaultValue || sourceKey;
-        }
-        const source = this.localizations$.value.get(sourceName);
-        if (!source) {
-            warn('Could not find localization source: ' + sourceName);
-            return defaultValue || sourceKey;
-        }
-        let localization = source[sourceKey];
-        if (typeof localization === 'undefined') {
-            return defaultValue || sourceKey;
-        }
-        interpolateParams = interpolateParams.filter(params => params != null);
-        if (localization)
-            localization = interpolate(localization, interpolateParams);
-        if (typeof localization !== 'string')
-            localization = '';
-        return localization || defaultValue || key;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LocalizationService, deps: [{ token: SessionStateService }, { token: i0.Injector }, { token: LocalizationService, optional: true, skipSelf: true }, { token: ConfigStateService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LocalizationService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.8", ngImport: i0, type: LocalizationService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: SessionStateService }, { type: i0.Injector }, { type: LocalizationService, decorators: [{
-                    type: Optional
-                }, {
-                    type: SkipSelf
-                }] }, { type: ConfigStateService }] });
-function recursivelyMergeBaseResources(baseResourceName, source) {
-    const item = source[baseResourceName];
-    if (item.baseResources.length === 0) {
-        return item;
+    // Helper method to create query parameters from UI model
+    static fromUIModel(model) {
+        const params = {
+            filters: model.advancedFilters || [],
+            orderBy: model.sorting || [],
+            groupBy: model.grouping || [],
+            select: model.columns || [],
+            aggregates: model.aggregates || [],
+            top: model.pagination?.top,
+            skip: model.pagination?.skip,
+            expand: model.expand,
+            includeCount: model.pagination?.includeCount
+        };
+        return params;
     }
-    return item.baseResources.reduce((acc, baseResource) => {
-        const baseItem = recursivelyMergeBaseResources(baseResource, source);
-        const texts = { ...baseItem.texts, ...item.texts };
-        return { ...acc, texts };
-    }, item);
-}
-function mergeResourcesWithBaseResource(resource) {
-    const entities = Object.keys(resource).map(key => {
-        const newValue = recursivelyMergeBaseResources(key, resource);
-        return [key, newValue];
-    });
-    return entities.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
-}
-function combineLegacyandNewResources(legacy, resource) {
-    const mergedResource = mergeResourcesWithBaseResource(resource);
-    return Object.entries(mergedResource).reduce((acc, [key, value]) => {
-        return { ...acc, [key]: value.texts };
-    }, legacy);
 }
 
 class LocalStorageListenerService {
@@ -2994,7 +2994,7 @@ async function getInitialData() {
     if (!options.skipInitAuthService && authService) {
         await authService.init();
     }
-    if (options.skipGetAppConfiguration)
+    if (options.skipGetAppConfiguration || authService?.isAuthenticated == false)
         return;
     const result$ = configState.refreshAppState().pipe(tap(() => checkAuthenticationState(injector)), tap(() => {
         const currentTenant = configState.getOne('currentTenant');