spiderly 0.0.2

package/esm2022/lib/modules/spiderly-transloco.module.mjs

@@ -0,0 +1,44 @@
+import { provideTransloco, TranslocoModule } from '@jsverse/transloco';
+import { NgModule } from '@angular/core';
+import { SpiderlyTranslocoLoader } from '../services/spiderly-transloco-loader';
+import { provideTranslocoPreloadLangs } from '@jsverse/transloco-preload-langs';
+import * as i0 from "@angular/core";
+export class SpiderlyTranslocoModule {
+    static forRoot() {
+        return {
+            ngModule: SpiderlyTranslocoModule,
+            providers: [
+                provideTranslocoPreloadLangs(['sr-Latn-RS']),
+                provideTransloco({
+                    config: {
+                        availableLangs: [
+                            'sr-Latn-RS', 'sr-Latn-RS.generated',
+                            'en', 'en.generated',
+                        ],
+                        defaultLang: 'sr-Latn-RS',
+                        fallbackLang: [
+                            'sr-Latn-RS.generated',
+                        ],
+                        missingHandler: {
+                            useFallbackTranslation: true,
+                            logMissingKey: false,
+                        },
+                        reRenderOnLangChange: true,
+                    },
+                    loader: SpiderlyTranslocoLoader
+                }),
+            ],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SpiderlyTranslocoModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: SpiderlyTranslocoModule, imports: [TranslocoModule], exports: [TranslocoModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SpiderlyTranslocoModule, imports: [TranslocoModule, TranslocoModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SpiderlyTranslocoModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [TranslocoModule],
+                    exports: [TranslocoModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/api.service.security.mjs

@@ -0,0 +1,86 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./config-base.service";
+export class ApiSecurityService {
+    constructor(http, config) {
+        this.http = http;
+        this.config = config;
+        //#region Authentication
+        this.register = (request) => {
+            return this.http.post(`${this.config.apiUrl}/Security/Register`, request, this.config.httpOptions);
+        };
+        this.sendRegistrationVerificationEmail = (registrationDTO) => {
+            return this.http.post(`${this.config.apiUrl}/Security/SendRegistrationVerificationEmail`, registrationDTO, this.config.httpOptions);
+        };
+        this.login = (request) => {
+            return this.http.post(`${this.config.apiUrl}/Security/Login`, request, this.config.httpOptions);
+        };
+        this.loginExternal = (externalProviderDTO) => {
+            return this.http.post(`${this.config.apiUrl}/Security/LoginExternal`, externalProviderDTO, this.config.httpOptions);
+        };
+        this.sendLoginVerificationEmail = (loginDTO) => {
+            return this.http.post(`${this.config.apiUrl}/Security/SendLoginVerificationEmail`, loginDTO, this.config.httpOptions);
+        };
+        this.logout = (browserId) => {
+            return this.http.get(`${this.config.apiUrl}/Security/Logout?browserId=${browserId}`);
+        };
+        this.refreshToken = (request) => {
+            return this.http.post(`${this.config.apiUrl}/Security/RefreshToken`, request, this.config.httpOptions);
+        };
+        //#endregion
+        //#region User
+        this.getCurrentUser = () => {
+            return this.http.get(`${this.config.apiUrl}/Security/GetCurrentUser`, this.config.httpSkipSpinnerOptions);
+        };
+        this.getCurrentUserPermissionCodes = () => {
+            return this.http.get(`${this.config.apiUrl}/Security/GetCurrentUserPermissionCodes`, this.config.httpSkipSpinnerOptions);
+        };
+        //#endregion
+        //#region Role
+        this.getRoleTableData = (dto) => {
+            return this.http.post(`${this.config.apiUrl}/Security/GetRoleTableData`, dto, this.config.httpSkipSpinnerOptions);
+        };
+        this.exportRoleTableDataToExcel = (dto) => {
+            return this.http.post(`${this.config.apiUrl}/Security/ExportRoleTableDataToExcel`, dto, this.config.httpOptions);
+        };
+        this.deleteRole = (id) => {
+            return this.http.delete(`${this.config.apiUrl}/Security/DeleteRole?id=${id}`);
+        };
+        this.getRoleMainUIFormDTO = (id) => {
+            return this.http.get(`${this.config.apiUrl}/Security/GetRoleMainUIFormDTO?id=${id}`);
+        };
+        this.getRole = (id) => {
+            return this.http.get(`${this.config.apiUrl}/Security/GetRole?id=${id}`);
+        };
+        this.saveRole = (dto) => {
+            return this.http.put(`${this.config.apiUrl}/Security/SaveRole`, dto, this.config.httpOptions);
+        };
+        this.getUsersNamebookListForRole = (roleId) => {
+            return this.http.get(`${this.config.apiUrl}/Security/GetUsersNamebookListForRole?roleId=${roleId}`, this.config.httpSkipSpinnerOptions);
+        };
+        this.getPermissionsDropdownListForRole = () => {
+            return this.http.get(`${this.config.apiUrl}/Security/GetPermissionsDropdownListForRole`, this.config.httpSkipSpinnerOptions);
+        };
+        this.getPermissionsNamebookListForRole = (roleId) => {
+            return this.http.get(`${this.config.apiUrl}/Security/GetPermissionsNamebookListForRole?roleId=${roleId}`, this.config.httpSkipSpinnerOptions);
+        };
+        this.getUsersAutocompleteListForRole = (limit, query) => {
+            return this.http.get(`${this.config.apiUrl}/Security/GetUsersAutocompleteListForRole?limit=${limit}&query=${query}`, this.config.httpSkipSpinnerOptions);
+        };
+        //#endregion
+        //#region Notification
+        this.getUnreadNotificationsCountForCurrentUser = () => {
+            return this.http.get(`${this.config.apiUrl}/Notification/GetUnreadNotificationsCountForCurrentUser`, this.config.httpSkipSpinnerOptions);
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ApiSecurityService, deps: [{ token: i1.HttpClient }, { token: i2.ConfigBaseService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ApiSecurityService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ApiSecurityService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ConfigBaseService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.service.security.js","sourceRoot":"","sources":["../../../../../projects/spiderly/src/lib/services/api.service.security.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { Observable } from 'rxjs';\r\nimport { Namebook } from '../entities/namebook';\r\nimport { TableFilter } from '../entities/table-filter';\r\nimport { Login, Registration, RegistrationVerificationResult, RefreshTokenRequest, AuthResult, Role, User, ExternalProvider, VerificationTokenRequest, RoleSaveBody, RoleMainUIForm } from '../entities/security-entities';\r\nimport { ConfigBaseService } from './config-base.service';\r\nimport { TableResponse } from '../entities/table-response';\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class ApiSecurityService {\r\n\r\n    constructor(\r\n        protected http: HttpClient,\r\n        protected config: ConfigBaseService\r\n    ) {\r\n        \r\n    }\r\n\r\n    //#region Authentication\r\n\r\n    register = (request: VerificationTokenRequest): Observable<AuthResult> => { \r\n        return this.http.post<AuthResult>(`${this.config.apiUrl}/Security/Register`, request, this.config.httpOptions);\r\n    }\r\n\r\n    sendRegistrationVerificationEmail = (registrationDTO: Registration): Observable<RegistrationVerificationResult> => { \r\n        return this.http.post<RegistrationVerificationResult>(`${this.config.apiUrl}/Security/SendRegistrationVerificationEmail`, registrationDTO, this.config.httpOptions);\r\n    }\r\n    \r\n    login = (request: VerificationTokenRequest): Observable<AuthResult> => { \r\n        return this.http.post<AuthResult>(`${this.config.apiUrl}/Security/Login`, request, this.config.httpOptions);\r\n    }\r\n\r\n    loginExternal = (externalProviderDTO: ExternalProvider): Observable<AuthResult> => { \r\n        return this.http.post<AuthResult>(`${this.config.apiUrl}/Security/LoginExternal`, externalProviderDTO, this.config.httpOptions);\r\n    }\r\n\r\n    sendLoginVerificationEmail = (loginDTO: Login): Observable<any> => { \r\n        return this.http.post<any>(`${this.config.apiUrl}/Security/SendLoginVerificationEmail`, loginDTO, this.config.httpOptions);\r\n    }\r\n\r\n\r\n    logout = (browserId: string): Observable<any> => { \r\n        return this.http.get<any>(`${this.config.apiUrl}/Security/Logout?browserId=${browserId}`);\r\n    }\r\n\r\n    refreshToken = (request: RefreshTokenRequest): Observable<AuthResult> => { \r\n        return this.http.post<AuthResult>(`${this.config.apiUrl}/Security/RefreshToken`, request, this.config.httpOptions);\r\n    }\r\n\r\n    //#endregion\r\n\r\n    //#region User\r\n\r\n    getCurrentUser = (): Observable<User> => { \r\n        return this.http.get<User>(`${this.config.apiUrl}/Security/GetCurrentUser`, this.config.httpSkipSpinnerOptions);\r\n    }\r\n\r\n    getCurrentUserPermissionCodes = (): Observable<string[]> => { \r\n        return this.http.get<string[]>(`${this.config.apiUrl}/Security/GetCurrentUserPermissionCodes`, this.config.httpSkipSpinnerOptions);\r\n    }\r\n\r\n    //#endregion\r\n\r\n    //#region Role\r\n\r\n    getRoleTableData = (dto: TableFilter): Observable<TableResponse> => { \r\n        return this.http.post<TableResponse>(`${this.config.apiUrl}/Security/GetRoleTableData`, dto, this.config.httpSkipSpinnerOptions);\r\n    }\r\n\r\n    exportRoleTableDataToExcel = (dto: TableFilter): Observable<any> => { \r\n        return this.http.post<any>(`${this.config.apiUrl}/Security/ExportRoleTableDataToExcel`, dto, this.config.httpOptions);\r\n    }\r\n\r\n    deleteRole = (id: number): Observable<any> => { \r\n        return this.http.delete<any>(`${this.config.apiUrl}/Security/DeleteRole?id=${id}`);\r\n    }\r\n\r\n    getRoleMainUIFormDTO = (id: number): Observable<RoleMainUIForm> => {\r\n        return this.http.get<RoleMainUIForm>(`${this.config.apiUrl}/Security/GetRoleMainUIFormDTO?id=${id}`);\r\n    }\r\n\r\n    getRole = (id: number): Observable<Role> => {\r\n        return this.http.get<Role>(`${this.config.apiUrl}/Security/GetRole?id=${id}`);\r\n    }\r\n\r\n    saveRole = (dto: RoleSaveBody): Observable<Role> => { \r\n        return this.http.put<Role>(`${this.config.apiUrl}/Security/SaveRole`, dto, this.config.httpOptions);\r\n    }\r\n\r\n    getUsersNamebookListForRole = (roleId: number): Observable<Namebook[]> => {\r\n        return this.http.get<Namebook[]>(`${this.config.apiUrl}/Security/GetUsersNamebookListForRole?roleId=${roleId}`, this.config.httpSkipSpinnerOptions);\r\n    }\r\n\r\n    getPermissionsDropdownListForRole = (): Observable<Namebook[]> => {\r\n        return this.http.get<Namebook[]>(`${this.config.apiUrl}/Security/GetPermissionsDropdownListForRole`, this.config.httpSkipSpinnerOptions);\r\n    }\r\n\r\n    getPermissionsNamebookListForRole = (roleId: number): Observable<Namebook[]> => {\r\n        return this.http.get<Namebook[]>(`${this.config.apiUrl}/Security/GetPermissionsNamebookListForRole?roleId=${roleId}`, this.config.httpSkipSpinnerOptions);\r\n    }\r\n\r\n    getUsersAutocompleteListForRole = (limit: number, query: string): Observable<Namebook[]> => {\r\n        return this.http.get<Namebook[]>(`${this.config.apiUrl}/Security/GetUsersAutocompleteListForRole?limit=${limit}&query=${query}`, this.config.httpSkipSpinnerOptions);\r\n    }\r\n\r\n    //#endregion\r\n\r\n    //#region Notification\r\n\r\n    getUnreadNotificationsCountForCurrentUser = (): Observable<number> => { \r\n        return this.http.get<number>(`${this.config.apiUrl}/Notification/GetUnreadNotificationsCountForCurrentUser`, this.config.httpSkipSpinnerOptions);\r\n    }\r\n\r\n    //#endregion\r\n\r\n}\r\n\r\n"]}

package/esm2022/lib/services/app-initializer.mjs

@@ -0,0 +1,6 @@
+export function authInitializer(authService) {
+    return () => {
+        return authService.refreshToken();
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLWluaXRpYWxpemVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc3BpZGVybHkvc3JjL2xpYi9zZXJ2aWNlcy9hcHAtaW5pdGlhbGl6ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsTUFBTSxVQUFVLGVBQWUsQ0FBQyxXQUE0QjtJQUMxRCxPQUFPLEdBQUcsRUFBRTtRQUNWLE9BQU8sV0FBVyxDQUFDLFlBQVksRUFBRSxDQUFDO0lBQ3BDLENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XHJcbmltcG9ydCB7IEF1dGhCYXNlU2VydmljZSB9IGZyb20gJy4vYXV0aC1iYXNlLnNlcnZpY2UnO1xyXG5pbXBvcnQgeyBBdXRoUmVzdWx0IH0gZnJvbSAnLi4vZW50aXRpZXMvc2VjdXJpdHktZW50aXRpZXMnO1xyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIGF1dGhJbml0aWFsaXplcihhdXRoU2VydmljZTogQXV0aEJhc2VTZXJ2aWNlKTogKCkgPT4gT2JzZXJ2YWJsZTxBdXRoUmVzdWx0PiB7XHJcbiAgcmV0dXJuICgpID0+IHtcclxuICAgIHJldHVybiBhdXRoU2VydmljZS5yZWZyZXNoVG9rZW4oKTtcclxuICB9O1xyXG59Il19

package/esm2022/lib/services/app-layout-base.service.mjs

@@ -0,0 +1,132 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, combineLatest, delay, map, of, Subject, withLatestFrom } from 'rxjs';
+import { InitTopBarData } from '../entities/init-top-bar-data';
+import * as i0 from "@angular/core";
+import * as i1 from "./api.service.security";
+import * as i2 from "./config-base.service";
+import * as i3 from "./auth-base.service";
+export class LayoutBaseService {
+    constructor(apiService, config, authService) {
+        this.apiService = apiService;
+        this.config = config;
+        this.authService = authService;
+        this._unreadNotificationsNumber = new BehaviorSubject(null);
+        this.unreadNotificationsCount$ = this._unreadNotificationsNumber.asObservable();
+        this.layoutConfig = {
+            ripple: false,
+            inputStyle: 'outlined',
+            menuMode: 'static',
+            colorScheme: 'light',
+            theme: 'lara-light-indigo',
+            scale: 14,
+            color: `var(--primary-color)`,
+        };
+        this.state = {
+            staticMenuDesktopInactive: false,
+            overlayMenuActive: false,
+            profileSidebarVisible: false,
+            profileDropdownSidebarVisible: false,
+            configSidebarVisible: false,
+            staticMenuMobileActive: false,
+            menuHoverActive: false
+        };
+        this.configUpdate = new Subject();
+        this.overlayOpen = new Subject();
+        this.configUpdate$ = this.configUpdate.asObservable();
+        this.overlayOpen$ = this.overlayOpen.asObservable();
+        this.initUnreadNotificationsCountForCurrentUser = () => {
+            this.initUnreadNotificationsCountForCurrentUserObservable().pipe(delay(1), // FT HACK: Adding delay so both additionalObservable and user emits single null value when logout
+            withLatestFrom(this.authService.user$) // Triggers when unread notifications change
+            ).subscribe(([additionalObservable, user]) => {
+                if (user != null && additionalObservable !== undefined) {
+                    this.setUnreadNotificationsCountForCurrentUser().subscribe();
+                }
+            });
+        };
+        this.initUnreadNotificationsCountForCurrentUserObservable = () => {
+            return this.authService.user$;
+        };
+        this.setUnreadNotificationsCountForCurrentUser = () => {
+            return this.apiService.getUnreadNotificationsCountForCurrentUser().pipe(map((unreadNotificationsCount) => {
+                this._unreadNotificationsNumber.next(unreadNotificationsCount);
+            }));
+        };
+        //#region Top Bar
+        this.initTopBarData = () => {
+            return combineLatest([this.authService.user$, this.unreadNotificationsCount$]).pipe(map(([currentUser, unreadNotificationsCount]) => {
+                return new InitTopBarData({
+                    companyName: this.config.companyName,
+                    userProfilePath: `/administration/users/${currentUser?.id}`,
+                    unreadNotificationsCount: unreadNotificationsCount,
+                    showProfileIcon: true,
+                    currentUser: currentUser,
+                });
+            }));
+        };
+        //#endregion
+        //#region Side Bar
+        this.searchPartners = (event) => {
+            return of();
+        };
+        this.partnersAutocompleteButtonClick = (selectedPartner) => { };
+    }
+    onMenuToggle() {
+        if (this.isOverlay()) {
+            this.state.overlayMenuActive = !this.state.overlayMenuActive;
+            if (this.state.overlayMenuActive) {
+                this.overlayOpen.next(null);
+            }
+        }
+        if (this.isDesktop()) {
+            this.state.staticMenuDesktopInactive = !this.state.staticMenuDesktopInactive;
+        }
+        else {
+            this.state.staticMenuMobileActive = !this.state.staticMenuMobileActive;
+            if (this.state.staticMenuMobileActive) {
+                this.overlayOpen.next(null);
+            }
+        }
+    }
+    showProfileSidebar() {
+        this.state.profileSidebarVisible = !this.state.profileSidebarVisible;
+        if (this.state.profileSidebarVisible) {
+            this.overlayOpen.next(null);
+        }
+    }
+    showProfileDropdownSidebar() {
+        this.state.profileDropdownSidebarVisible = !this.state.profileDropdownSidebarVisible;
+        if (this.state.profileDropdownSidebarVisible) {
+            this.overlayOpen.next(null);
+        }
+    }
+    showConfigSidebar() {
+        this.state.configSidebarVisible = true;
+    }
+    isOverlay() {
+        return this.layoutConfig.menuMode === 'overlay';
+    }
+    isDesktop() {
+        return window.innerWidth > 991;
+    }
+    isMobile() {
+        return !this.isDesktop();
+    }
+    onConfigUpdate() {
+        this.configUpdate.next(this.layoutConfig);
+    }
+    //#endregion
+    ngOnDestroy() {
+        if (this.userSubscription) {
+            this.userSubscription.unsubscribe();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LayoutBaseService, deps: [{ token: i1.ApiSecurityService }, { token: i2.ConfigBaseService }, { token: i3.AuthBaseService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LayoutBaseService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LayoutBaseService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ApiSecurityService }, { type: i2.ConfigBaseService }, { type: i3.AuthBaseService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-layout-base.service.js","sourceRoot":"","sources":["../../../../../projects/spiderly/src/lib/services/app-layout-base.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { AuthBaseService } from './auth-base.service';\r\nimport { ApiSecurityService } from './api.service.security';\r\nimport { Injectable, OnDestroy } from '@angular/core';\r\nimport { BehaviorSubject, combineLatest, delay, lastValueFrom, map, Observable, of, Subject, Subscription, withLatestFrom } from 'rxjs';\r\nimport { InitTopBarData } from '../entities/init-top-bar-data';\r\nimport { ConfigBaseService } from './config-base.service';\r\nimport { PrimengOption } from '../entities/primeng-option';\r\nimport { AutoCompleteCompleteEvent } from 'primeng/autocomplete';\r\n\r\nexport interface AppConfig {\r\n    inputStyle: string;\r\n    colorScheme: string; \r\n    theme: string;\r\n    ripple: boolean;\r\n    menuMode: string;\r\n    scale: number;\r\n    color: string;\r\n}\r\n\r\ninterface LayoutState {\r\n    staticMenuDesktopInactive: boolean;\r\n    overlayMenuActive: boolean;\r\n    profileSidebarVisible: boolean;\r\n    profileDropdownSidebarVisible:boolean;\r\n    configSidebarVisible: boolean;\r\n    staticMenuMobileActive: boolean;\r\n    menuHoverActive: boolean;\r\n}\r\n\r\n@Injectable({\r\n    providedIn: 'root',\r\n})\r\nexport class LayoutBaseService implements OnDestroy {\r\n    userSubscription: Subscription;\r\n\r\n    protected _unreadNotificationsNumber = new BehaviorSubject<number | null>(null);\r\n    unreadNotificationsCount$ = this._unreadNotificationsNumber.asObservable();\r\n\r\n    layoutConfig: AppConfig = {\r\n        ripple: false,\r\n        inputStyle: 'outlined',\r\n        menuMode: 'static',\r\n        colorScheme: 'light',\r\n        theme: 'lara-light-indigo',\r\n        scale: 14,\r\n        color: `var(--primary-color)`,\r\n    };\r\n\r\n    state: LayoutState = {\r\n        staticMenuDesktopInactive: false,\r\n        overlayMenuActive: false,\r\n        profileSidebarVisible: false,\r\n        profileDropdownSidebarVisible: false,\r\n        configSidebarVisible: false,\r\n        staticMenuMobileActive: false,\r\n        menuHoverActive: false\r\n    };\r\n\r\n    private configUpdate = new Subject<AppConfig>();\r\n\r\n    private overlayOpen = new Subject<any>();\r\n\r\n    configUpdate$ = this.configUpdate.asObservable();\r\n\r\n    overlayOpen$ = this.overlayOpen.asObservable();\r\n\r\n    constructor(\r\n        protected apiService: ApiSecurityService,\r\n        protected config: ConfigBaseService,\r\n        protected authService: AuthBaseService\r\n    ) {\r\n    }\r\n\r\n    initUnreadNotificationsCountForCurrentUser = () => {\r\n        this.initUnreadNotificationsCountForCurrentUserObservable().pipe(\r\n            delay(1), // FT HACK: Adding delay so both additionalObservable and user emits single null value when logout\r\n            withLatestFrom(this.authService.user$) // Triggers when unread notifications change\r\n        ).subscribe(([additionalObservable, user]) => {\r\n            if (user != null && additionalObservable !== undefined) {\r\n                this.setUnreadNotificationsCountForCurrentUser().subscribe();\r\n            }\r\n        });\r\n    }\r\n\r\n    initUnreadNotificationsCountForCurrentUserObservable = (): Observable<any> => {\r\n        return this.authService.user$;\r\n    }\r\n\r\n    setUnreadNotificationsCountForCurrentUser = (): Observable<any> => {\r\n        return this.apiService.getUnreadNotificationsCountForCurrentUser().pipe(\r\n            map((unreadNotificationsCount) => {\r\n                this._unreadNotificationsNumber.next(unreadNotificationsCount);\r\n            })\r\n        );\r\n    }\r\n\r\n    onMenuToggle() {\r\n        if (this.isOverlay()) {\r\n            this.state.overlayMenuActive = !this.state.overlayMenuActive;\r\n            if (this.state.overlayMenuActive) {\r\n                this.overlayOpen.next(null);\r\n            }\r\n        }\r\n\r\n        if (this.isDesktop()) {\r\n            this.state.staticMenuDesktopInactive = !this.state.staticMenuDesktopInactive;\r\n        }\r\n        else {\r\n            this.state.staticMenuMobileActive = !this.state.staticMenuMobileActive;\r\n\r\n            if (this.state.staticMenuMobileActive) {\r\n                this.overlayOpen.next(null);\r\n            }\r\n        }\r\n    }\r\n\r\n    showProfileSidebar() {\r\n        this.state.profileSidebarVisible = !this.state.profileSidebarVisible;\r\n        if (this.state.profileSidebarVisible) {\r\n            this.overlayOpen.next(null);\r\n        }\r\n    }\r\n\r\n    showProfileDropdownSidebar() {\r\n        this.state.profileDropdownSidebarVisible = !this.state.profileDropdownSidebarVisible;\r\n        if (this.state.profileDropdownSidebarVisible) {\r\n            this.overlayOpen.next(null);\r\n        }\r\n    }\r\n\r\n    showConfigSidebar() {\r\n        this.state.configSidebarVisible = true;\r\n    }\r\n\r\n    isOverlay() {\r\n        return this.layoutConfig.menuMode === 'overlay';\r\n    }\r\n\r\n    isDesktop() {\r\n        return window.innerWidth > 991;\r\n    }\r\n\r\n    isMobile() {\r\n        return !this.isDesktop();\r\n    }\r\n\r\n    onConfigUpdate() {\r\n        this.configUpdate.next(this.layoutConfig);\r\n    }\r\n    \r\n    //#region Top Bar\r\n\r\n    initTopBarData = (): Observable<InitTopBarData> => {\r\n        return combineLatest([this.authService.user$, this.unreadNotificationsCount$]).pipe(\r\n            map(([currentUser, unreadNotificationsCount]) => {\r\n                return new InitTopBarData({\r\n                    companyName: this.config.companyName,\r\n                    userProfilePath: `/administration/users/${currentUser?.id}`,\r\n                    unreadNotificationsCount: unreadNotificationsCount,\r\n                    showProfileIcon: true,\r\n                    currentUser: currentUser,\r\n                });\r\n            })\r\n        );\r\n    }\r\n\r\n    //#endregion\r\n\r\n    //#region Side Bar\r\n\r\n    searchPartners = (event: AutoCompleteCompleteEvent): Observable<PrimengOption[]> => {\r\n        return of();\r\n    }\r\n\r\n    partnersAutocompleteButtonClick = (selectedPartner: PrimengOption) => {}\r\n\r\n    //#endregion\r\n\r\n    ngOnDestroy(): void {\r\n        if (this.userSubscription) {\r\n            this.userSubscription.unsubscribe();\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2022/lib/services/auth-base.service.mjs

@@ -0,0 +1,220 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, of, Subject } from 'rxjs';
+import { map, tap, delay, finalize } from 'rxjs/operators';
+import { RefreshTokenRequest } from '../entities/security-entities';
+import { InitCompanyAuthDialogDetails } from '../entities/init-company-auth-dialog-details';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/common/http";
+import * as i3 from "@abacritt/angularx-social-login";
+import * as i4 from "./api.service.security";
+import * as i5 from "./config-base.service";
+export class AuthBaseService {
+    constructor(router, http, externalAuthService, apiService, config) {
+        this.router = router;
+        this.http = http;
+        this.externalAuthService = externalAuthService;
+        this.apiService = apiService;
+        this.config = config;
+        this.apiUrl = this.config.apiUrl;
+        this._currentUserPermissionCodes = new BehaviorSubject(undefined);
+        this.currentUserPermissionCodes$ = this._currentUserPermissionCodes.asObservable();
+        this._user = new BehaviorSubject(undefined);
+        this.user$ = this._user.asObservable();
+        // Google auth
+        this.authChangeSub = new Subject();
+        this.extAuthChangeSub = new Subject();
+        this.authChanged = this.authChangeSub.asObservable();
+        this.extAuthChanged = this.extAuthChangeSub.asObservable();
+        this.storageEventListener = (event) => {
+            if (event.storageArea === localStorage) {
+                if (event.key === 'logout-event') {
+                    this.stopTokenTimer();
+                    this._user.next(null);
+                    this._currentUserPermissionCodes.next(null);
+                }
+                if (event.key === 'login-event') {
+                    this.stopTokenTimer();
+                    this.apiService.getCurrentUser().subscribe((user) => {
+                        this._user.next({
+                            id: user.id,
+                            email: user.email
+                        });
+                        this.setCurrentUserPermissionCodes().subscribe();
+                    });
+                }
+            }
+        };
+        this.onAfterLogout = () => {
+            this._currentUserPermissionCodes.next(null);
+        };
+        this.onAfterRefreshToken = () => {
+            this.setCurrentUserPermissionCodes().subscribe(); // FT: Needs to be after setting local storage
+        };
+        this.logoutGoogle = () => {
+            this.externalAuthService.signOut();
+        };
+        this.initCompanyAuthDialogDetails = () => {
+            return of(new InitCompanyAuthDialogDetails({
+                image: `assets/images/logo/logo.svg`,
+                companyName: this.config.companyName,
+            }));
+        };
+        this.onAfterNgOnDestroy = () => { };
+        window.addEventListener('storage', this.storageEventListener);
+        // Google auth
+        this.externalAuthService.authState.subscribe((user) => {
+            const externalAuth = {
+                // provider: user.provider,
+                idToken: user.idToken
+            };
+            this.loginExternal(externalAuth).subscribe(() => {
+                this.navigateToDashboard();
+            });
+            this.extAuthChangeSub.next(user);
+        });
+    }
+    sendLoginVerificationEmail(body) {
+        const browserId = this.getBrowserId();
+        body.browserId = browserId;
+        return this.apiService.sendLoginVerificationEmail(body);
+    }
+    login(body) {
+        const browserId = this.getBrowserId();
+        body.browserId = browserId;
+        const loginResultObservable = this.http.post(`${this.apiUrl}/Security/Login`, body);
+        return this.handleLoginResult(loginResultObservable);
+    }
+    loginExternal(body) {
+        const browserId = this.getBrowserId();
+        body.browserId = browserId;
+        const loginResultObservable = this.http.post(`${this.apiUrl}/Security/LoginExternal`, body);
+        return this.handleLoginResult(loginResultObservable);
+    }
+    sendRegistrationVerificationEmail(body) {
+        const browserId = this.getBrowserId();
+        body.browserId = browserId;
+        return this.apiService.sendRegistrationVerificationEmail(body);
+    }
+    register(body) {
+        const browserId = this.getBrowserId();
+        body.browserId = browserId;
+        const loginResultObservable = this.apiService.register(body);
+        return this.handleLoginResult(loginResultObservable);
+    }
+    handleLoginResult(loginResultObservable) {
+        return loginResultObservable.pipe(map(async (loginResult) => {
+            this.setLocalStorage(loginResult);
+            this._user.next({
+                id: loginResult.userId,
+                email: loginResult.email,
+            });
+            this.startTokenTimer();
+            this.setCurrentUserPermissionCodes().subscribe();
+            return loginResult;
+        }));
+    }
+    logout() {
+        const browserId = this.getBrowserId();
+        this.http
+            .get(`${this.apiUrl}/Security/Logout?browserId=${browserId}`)
+            .pipe(finalize(() => {
+            this.clearLocalStorage();
+            this._user.next(null);
+            this.onAfterLogout();
+            this.stopTokenTimer();
+            this.router.navigate([this.config.loginSlug]);
+        }))
+            .subscribe();
+    }
+    refreshToken() {
+        let refreshToken = localStorage.getItem(this.config.refreshTokenKey);
+        if (!refreshToken) {
+            this.clearLocalStorage();
+            return of(null);
+        }
+        const browserId = this.getBrowserId();
+        let body = new RefreshTokenRequest();
+        body.browserId = browserId;
+        body.refreshToken = refreshToken;
+        return this.http
+            .post(`${this.apiUrl}/Security/RefreshToken`, body, this.config.httpSkipSpinnerOptions)
+            .pipe(map((loginResult) => {
+            this._user.next({
+                id: loginResult.userId,
+                email: loginResult.email
+            });
+            this.setLocalStorage(loginResult);
+            this.startTokenTimer();
+            this.onAfterRefreshToken();
+            return loginResult;
+        }));
+    }
+    setLocalStorage(loginResult) {
+        localStorage.setItem(this.config.accessTokenKey, loginResult.accessToken);
+        localStorage.setItem(this.config.refreshTokenKey, loginResult.refreshToken);
+        localStorage.setItem('login-event', 'login' + Math.random());
+    }
+    clearLocalStorage() {
+        localStorage.removeItem(this.config.accessTokenKey);
+        localStorage.removeItem(this.config.refreshTokenKey);
+        localStorage.setItem('logout-event', 'logout' + Math.random());
+    }
+    getBrowserId() {
+        let browserId = localStorage.getItem(this.config.browserIdKey); // FT: We don't need to remove this from the local storage ever, only if the user manuely deletes it, we will handle it
+        if (!browserId) {
+            browserId = crypto.randomUUID();
+            localStorage.setItem(this.config.browserIdKey, browserId);
+        }
+        return browserId;
+    }
+    isAccessTokenExpired() {
+        const expired = this.getTokenRemainingTime() < 5000;
+        return of(expired);
+    }
+    getTokenRemainingTime() {
+        const accessToken = this.getAccessToken();
+        if (!accessToken) {
+            return 0;
+        }
+        const jwtToken = JSON.parse(atob(accessToken.split('.')[1]));
+        const expires = new Date(jwtToken.exp * 1000);
+        return expires.getTime() - Date.now();
+    }
+    getAccessToken() {
+        return localStorage.getItem(this.config.accessTokenKey);
+    }
+    startTokenTimer() {
+        const timeout = this.getTokenRemainingTime();
+        this.timer = of(true)
+            .pipe(delay(timeout), tap({
+            next: () => this.refreshToken().subscribe(),
+        }))
+            .subscribe();
+    }
+    stopTokenTimer() {
+        this.timer?.unsubscribe();
+    }
+    navigateToDashboard() {
+        this.router.navigate(['/']);
+    }
+    setCurrentUserPermissionCodes() {
+        return this.apiService.getCurrentUserPermissionCodes().pipe(map(permissionCodes => {
+            this._currentUserPermissionCodes.next(permissionCodes);
+            return permissionCodes;
+        }));
+    }
+    ngOnDestroy() {
+        window.removeEventListener('storage', this.storageEventListener.bind(this));
+        this.onAfterNgOnDestroy();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthBaseService, deps: [{ token: i1.Router }, { token: i2.HttpClient }, { token: i3.SocialAuthService }, { token: i4.ApiSecurityService }, { token: i5.ConfigBaseService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthBaseService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthBaseService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i2.HttpClient }, { type: i3.SocialAuthService }, { type: i4.ApiSecurityService }, { type: i5.ConfigBaseService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-base.service.js","sourceRoot":"","sources":["../../../../../projects/spiderly/src/lib/services/auth-base.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\r\nimport { Router } from '@angular/router';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { BehaviorSubject, firstValueFrom, Observable, of, Subject, Subscription } from 'rxjs';\r\nimport { map, tap, delay, finalize } from 'rxjs/operators';\r\nimport { SocialUser, SocialAuthService } from '@abacritt/angularx-social-login';\r\nimport { ExternalProvider, Login, VerificationTokenRequest, AuthResult, Registration, RegistrationVerificationResult, RefreshTokenRequest, User } from '../entities/security-entities';\r\nimport { ConfigBaseService } from './config-base.service';\r\nimport { ApiSecurityService } from './api.service.security';\r\nimport { InitCompanyAuthDialogDetails } from '../entities/init-company-auth-dialog-details';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AuthBaseService implements OnDestroy {\r\n  private readonly apiUrl = this.config.apiUrl;\r\n  private timer?: Subscription;\r\n\r\n  protected _currentUserPermissionCodes = new BehaviorSubject<string[] | null>(undefined);\r\n  currentUserPermissionCodes$ = this._currentUserPermissionCodes.asObservable();\r\n\r\n  protected _user = new BehaviorSubject<User | null>(undefined);\r\n  user$ = this._user.asObservable();\r\n\r\n  // Google auth\r\n  private authChangeSub = new Subject<boolean>();\r\n  private extAuthChangeSub = new Subject<SocialUser>();\r\n  public authChanged = this.authChangeSub.asObservable();\r\n  public extAuthChanged = this.extAuthChangeSub.asObservable();\r\n  \r\n  constructor(\r\n    protected router: Router,\r\n    protected http: HttpClient,\r\n    protected externalAuthService: SocialAuthService,\r\n    protected apiService: ApiSecurityService,\r\n    protected config: ConfigBaseService,\r\n  ) {\r\n    window.addEventListener('storage', this.storageEventListener);\r\n\r\n    // Google auth\r\n    this.externalAuthService.authState.subscribe((user) => {\r\n      const externalAuth: ExternalProvider = {\r\n        // provider: user.provider,\r\n        idToken: user.idToken\r\n      }\r\n      this.loginExternal(externalAuth).subscribe(() => {\r\n        this.navigateToDashboard();\r\n      });\r\n      this.extAuthChangeSub.next(user);\r\n    });\r\n  }\r\n\r\n  private storageEventListener = (event: StorageEvent) => {\r\n    if (event.storageArea === localStorage) {\r\n      if (event.key === 'logout-event') {\r\n        this.stopTokenTimer();\r\n        this._user.next(null);\r\n\r\n        this._currentUserPermissionCodes.next(null);\r\n      }\r\n      if (event.key === 'login-event') {\r\n        this.stopTokenTimer();\r\n\r\n        this.apiService.getCurrentUser().subscribe((user: User) => {\r\n            this._user.next({\r\n              id: user.id,\r\n              email: user.email\r\n            });\r\n\r\n            this.setCurrentUserPermissionCodes().subscribe();\r\n          });\r\n      }\r\n    }\r\n  }\r\n\r\n  sendLoginVerificationEmail(body: Login): Observable<any> {\r\n    const browserId = this.getBrowserId();\r\n    body.browserId = browserId;\r\n    return this.apiService.sendLoginVerificationEmail(body);\r\n  }\r\n\r\n  login(body: VerificationTokenRequest): Observable<Promise<AuthResult>> {\r\n    const browserId = this.getBrowserId();\r\n    body.browserId = browserId;\r\n    const loginResultObservable = this.http.post<AuthResult>(`${this.apiUrl}/Security/Login`, body);\r\n    return this.handleLoginResult(loginResultObservable);\r\n  }\r\n\r\n  loginExternal(body: ExternalProvider): Observable<Promise<AuthResult>> {\r\n    const browserId = this.getBrowserId();\r\n    body.browserId = browserId;\r\n    const loginResultObservable = this.http.post<AuthResult>(`${this.apiUrl}/Security/LoginExternal`, body);\r\n    return this.handleLoginResult(loginResultObservable);\r\n  }\r\n\r\n  sendRegistrationVerificationEmail(body: Registration): Observable<RegistrationVerificationResult> {\r\n    const browserId = this.getBrowserId();\r\n    body.browserId = browserId;\r\n    return this.apiService.sendRegistrationVerificationEmail(body);\r\n  }\r\n  \r\n  register(body: VerificationTokenRequest): Observable<Promise<AuthResult>> {\r\n    const browserId = this.getBrowserId();\r\n    body.browserId = browserId;\r\n    const loginResultObservable = this.apiService.register(body);\r\n    return this.handleLoginResult(loginResultObservable);\r\n  }\r\n\r\n  handleLoginResult(loginResultObservable: Observable<AuthResult>){\r\n    return loginResultObservable.pipe(\r\n      map(async (loginResult: AuthResult) => {\r\n        this.setLocalStorage(loginResult);\r\n        this._user.next({\r\n          id: loginResult.userId,\r\n          email: loginResult.email,\r\n        });\r\n        this.startTokenTimer();\r\n        this.setCurrentUserPermissionCodes().subscribe()\r\n        return loginResult;\r\n      })\r\n    );\r\n  }\r\n\r\n  logout() {\r\n    const browserId = this.getBrowserId();\r\n    this.http\r\n      .get(`${this.apiUrl}/Security/Logout?browserId=${browserId}`)\r\n      .pipe(\r\n        finalize(() => {\r\n          this.clearLocalStorage();\r\n          this._user.next(null);\r\n          this.onAfterLogout();\r\n          this.stopTokenTimer();\r\n          this.router.navigate([this.config.loginSlug]);\r\n        })\r\n      )\r\n      .subscribe();\r\n  }\r\n\r\n  onAfterLogout = () => {\r\n    this._currentUserPermissionCodes.next(null);\r\n  }\r\n\r\n  refreshToken(): Observable<AuthResult> {\r\n    let refreshToken = localStorage.getItem(this.config.refreshTokenKey);\r\n\r\n    if (!refreshToken) {\r\n      this.clearLocalStorage();\r\n      return of(null);\r\n    }\r\n\r\n    const browserId = this.getBrowserId();\r\n    let body: RefreshTokenRequest = new RefreshTokenRequest();\r\n    body.browserId = browserId;\r\n    body.refreshToken = refreshToken;\r\n    \r\n    return this.http\r\n      .post<AuthResult>(`${this.apiUrl}/Security/RefreshToken`, body, this.config.httpSkipSpinnerOptions)\r\n      .pipe(\r\n        map((loginResult) => {\r\n          this._user.next({\r\n            id: loginResult.userId,\r\n            email: loginResult.email\r\n          });\r\n          \r\n          this.setLocalStorage(loginResult);\r\n          this.startTokenTimer();\r\n          this.onAfterRefreshToken();\r\n          \r\n          return loginResult;\r\n        })\r\n      );\r\n  }\r\n\r\n  onAfterRefreshToken = () => {\r\n    this.setCurrentUserPermissionCodes().subscribe(); // FT: Needs to be after setting local storage\r\n  }\r\n\r\n  setLocalStorage(loginResult: AuthResult) {\r\n    localStorage.setItem(this.config.accessTokenKey, loginResult.accessToken);\r\n    localStorage.setItem(this.config.refreshTokenKey, loginResult.refreshToken);\r\n    localStorage.setItem('login-event', 'login' + Math.random());\r\n  }\r\n\r\n  clearLocalStorage() {\r\n    localStorage.removeItem(this.config.accessTokenKey);\r\n    localStorage.removeItem(this.config.refreshTokenKey);\r\n    localStorage.setItem('logout-event', 'logout' + Math.random());\r\n  }\r\n\r\n  getBrowserId(): string {\r\n    let browserId = localStorage.getItem(this.config.browserIdKey); // FT: We don't need to remove this from the local storage ever, only if the user manuely deletes it, we will handle it\r\n    if (!browserId) {\r\n      browserId = crypto.randomUUID();\r\n      localStorage.setItem(this.config.browserIdKey, browserId);\r\n    }\r\n    return browserId;\r\n  }\r\n\r\n  isAccessTokenExpired(): Observable<boolean> {\r\n    const expired = this.getTokenRemainingTime() < 5000;\r\n    \r\n    return of(expired);\r\n  }\r\n\r\n  getTokenRemainingTime(): number {\r\n    const accessToken = this.getAccessToken();\r\n\r\n    if (!accessToken) {\r\n      return 0;\r\n    }\r\n\r\n    const jwtToken = JSON.parse(atob(accessToken.split('.')[1]));\r\n    const expires = new Date(jwtToken.exp * 1000);\r\n    \r\n    return expires.getTime() - Date.now();\r\n  }\r\n\r\n  getAccessToken(): string {\r\n    return localStorage.getItem(this.config.accessTokenKey);\r\n  }\r\n\r\n  private startTokenTimer() {\r\n    const timeout = this.getTokenRemainingTime();\r\n    this.timer = of(true)\r\n      .pipe(\r\n        delay(timeout),\r\n        tap({\r\n          next: () => this.refreshToken().subscribe(),\r\n        })\r\n      )\r\n      .subscribe();\r\n  }\r\n\r\n  private stopTokenTimer() {\r\n    this.timer?.unsubscribe();\r\n  }\r\n\r\n  navigateToDashboard(){\r\n    this.router.navigate(['/']);\r\n  }\r\n\r\n  logoutGoogle = () => {\r\n    this.externalAuthService.signOut();\r\n  }\r\n\r\n  initCompanyAuthDialogDetails = (): Observable<InitCompanyAuthDialogDetails> => {\r\n    return of(\r\n      new InitCompanyAuthDialogDetails ({\r\n        image: `assets/images/logo/logo.svg`, \r\n        companyName: this.config.companyName,\r\n      })\r\n    );\r\n  }\r\n\r\n  setCurrentUserPermissionCodes(): Observable<string[]> {\r\n    return this.apiService.getCurrentUserPermissionCodes().pipe(\r\n      map(permissionCodes => {\r\n        this._currentUserPermissionCodes.next(permissionCodes);\r\n        return permissionCodes;\r\n      }\r\n    ));\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    window.removeEventListener('storage', this.storageEventListener.bind(this));\r\n    this.onAfterNgOnDestroy();\r\n  }\r\n\r\n  onAfterNgOnDestroy = () => {};\r\n}\r\n"]}