@stemy/ngx-utils 12.1.3 → 13.0.2

package/esm2020/ngx-utils/utils/auth.guard.mjs

@@ -0,0 +1,181 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Inject, Injectable, Injector } from "@angular/core";
+import { AUTH_SERVICE, FactoryDependencies } from "../common-types";
+import { ReflectUtils } from "./reflect.utils";
+import { ObjectUtils } from "./object.utils";
+import { StateService } from "../services/state.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../services/state.service";
+export class AuthGuard {
+    constructor(injector, state, auth) {
+        this.injector = injector;
+        this.state = state;
+        this.auth = auth;
+    }
+    static guardAuthenticated(auth) {
+        return Promise.resolve(auth.isAuthenticated);
+    }
+    static guardNotAuthenticated(auth) {
+        return Promise.resolve(!auth.isAuthenticated);
+    }
+    static guardNothing() {
+        return Promise.resolve(true);
+    }
+    static guardAuthField(auth, expression = `auth.isAuthenticated`) {
+        // @dynamic
+        const lambda = () => {
+            return Promise.resolve(ObjectUtils.evaluate(expression, { auth }));
+        };
+        return lambda;
+    }
+    static guardStateField(state, expression = `state.data`) {
+        // @dynamic
+        const lambda = () => {
+            return Promise.resolve(ObjectUtils.evaluate(expression, { state }));
+        };
+        return lambda;
+    }
+    static guardAuthStateField(auth, state, expression = `auth.isAuthenticated`) {
+        // @dynamic
+        const lambda = () => {
+            return Promise.resolve(ObjectUtils.evaluate(expression, { auth, state }));
+        };
+        return lambda;
+    }
+    static wildRouteMatch(segments) {
+        return { consumed: segments };
+    }
+    static noRouteMatch() {
+        return null;
+    }
+    checkRouteMenu(route) {
+        if (!route.data || !route.data.name)
+            return Promise.resolve(false);
+        return this.checkRoute(route);
+    }
+    checkRoute(route, next) {
+        const routeData = route.data || {};
+        if (!routeData.guards)
+            return Promise.resolve(!route.canActivate || this.auth.isAuthenticated);
+        return new Promise(resolve => {
+            const guards = routeData.guards.map(g => {
+                const guard = ReflectUtils.resolve(g, this.injector);
+                return guard(this.auth, route, next);
+            });
+            Promise.all(guards).then(results => {
+                resolve(results.indexOf(false) < 0);
+            });
+        });
+    }
+    canActivate(next, state) {
+        const route = next.routeConfig;
+        return new Promise(resolve => {
+            this.auth.checkAuthenticated().then(() => {
+                this.checkRoute(route, next).then(hasRights => {
+                    resolve(hasRights);
+                    if (!hasRights) {
+                        this.getReturnState(route).then(returnState => {
+                            if (!returnState)
+                                return;
+                            this.state.navigate(returnState, { queryParams: next.queryParams });
+                        });
+                    }
+                });
+            });
+        });
+    }
+    getConfig(route, config, path) {
+        if (!config)
+            return null;
+        const match = config.findIndex(t => t == route);
+        if (match >= 0)
+            return config;
+        for (const subConfig of config) {
+            if (subConfig.path)
+                path.push(subConfig.path);
+            const loadedChildren = (subConfig["_loadedConfig"] || { routes: null }).routes;
+            const match = this.getConfig(route, subConfig.children || loadedChildren, path);
+            if (!match) {
+                if (subConfig.path)
+                    path.length -= 1;
+                continue;
+            }
+            return match;
+        }
+        return null;
+    }
+    getReturnState(route) {
+        if (!route)
+            return Promise.resolve(null);
+        if (ObjectUtils.isObject(route.data) && ObjectUtils.isArray(route.data.returnState)) {
+            return Promise.resolve(route.data.returnState);
+        }
+        const path = [];
+        const config = this.getConfig(route, this.state.routerConfig, path);
+        return new Promise(resolve => {
+            this.getReturnStateRecursive(config).then(rs => {
+                if (!ObjectUtils.isArray(rs)) {
+                    resolve(rs);
+                    return;
+                }
+                resolve(path.concat(rs));
+            });
+        });
+    }
+    getReturnStateRecursive(config, c = 0) {
+        if (!config || c >= config.length)
+            return Promise.resolve(null);
+        return new Promise(resolve => {
+            const route = config[c];
+            const check = !route.component ? Promise.resolve(false) : this.checkRoute(route);
+            check.then(res => {
+                if (res) {
+                    resolve([route.path]);
+                    return;
+                }
+                this.getReturnStateRecursive(config, c + 1).then(resolve);
+            });
+        });
+    }
+}
+AuthGuard.ɵfac = function AuthGuard_Factory(t) { return new (t || AuthGuard)(i0.ɵɵinject(Injector), i0.ɵɵinject(StateService), i0.ɵɵinject(AUTH_SERVICE)); };
+AuthGuard.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AuthGuard, factory: AuthGuard.ɵfac });
+__decorate([
+    FactoryDependencies(AUTH_SERVICE),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Function)
+], AuthGuard, "guardAuthField", null);
+__decorate([
+    FactoryDependencies(StateService),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [StateService, String]),
+    __metadata("design:returntype", Function)
+], AuthGuard, "guardStateField", null);
+__decorate([
+    FactoryDependencies(AUTH_SERVICE, StateService),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, StateService, String]),
+    __metadata("design:returntype", Function)
+], AuthGuard, "guardAuthStateField", null);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AuthGuard, [{
+        type: Injectable
+    }], function () { return [{ type: i0.Injector, decorators: [{
+                type: Inject,
+                args: [Injector]
+            }] }, { type: i1.StateService, decorators: [{
+                type: Inject,
+                args: [StateService]
+            }] }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [AUTH_SERVICE]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.guard.js","sourceRoot":"","sources":["../../../../src/ngx-utils/utils/auth.guard.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, Injector} from \"@angular/core\";\r\nimport {ActivatedRouteSnapshot, CanActivate, RouterStateSnapshot, UrlSegment} from \"@angular/router\";\r\nimport {AUTH_SERVICE, FactoryDependencies, IAuthService, IRoute, RouteValidator} from \"../common-types\";\r\nimport {ReflectUtils} from \"./reflect.utils\";\r\nimport {ObjectUtils} from \"./object.utils\";\r\nimport {StateService} from \"../services/state.service\";\r\n\r\n@Injectable()\r\nexport class AuthGuard implements CanActivate {\r\n\r\n    static guardAuthenticated(auth: IAuthService): Promise<boolean> {\r\n        return Promise.resolve(auth.isAuthenticated);\r\n    }\r\n\r\n    static guardNotAuthenticated(auth: IAuthService): Promise<boolean> {\r\n        return Promise.resolve(!auth.isAuthenticated);\r\n    }\r\n\r\n    static guardNothing(): Promise<boolean> {\r\n        return Promise.resolve(true);\r\n    }\r\n\r\n    @FactoryDependencies(AUTH_SERVICE)\r\n    static guardAuthField(auth: IAuthService, expression: string = `auth.isAuthenticated`): RouteValidator {\r\n        // @dynamic\r\n        const lambda = (): Promise<boolean> => {\r\n            return Promise.resolve(ObjectUtils.evaluate(expression, {auth}));\r\n        };\r\n        return lambda;\r\n    }\r\n\r\n    @FactoryDependencies(StateService)\r\n    static guardStateField(state: StateService, expression: string = `state.data`): RouteValidator {\r\n        // @dynamic\r\n        const lambda = (): Promise<boolean> => {\r\n            return Promise.resolve(ObjectUtils.evaluate(expression, {state}));\r\n        };\r\n        return lambda;\r\n    }\r\n\r\n    @FactoryDependencies(AUTH_SERVICE, StateService)\r\n    static guardAuthStateField(auth: IAuthService, state: StateService, expression: string = `auth.isAuthenticated`): RouteValidator {\r\n        // @dynamic\r\n        const lambda = (): Promise<boolean> => {\r\n            return Promise.resolve(ObjectUtils.evaluate(expression, {auth, state}));\r\n        };\r\n        return lambda;\r\n    }\r\n\r\n    static wildRouteMatch(segments: UrlSegment[]) {\r\n        return {consumed: segments};\r\n    }\r\n\r\n    static noRouteMatch() {\r\n        return null;\r\n    }\r\n\r\n    constructor(@Inject(Injector) readonly injector: Injector,\r\n                @Inject(StateService) readonly state: StateService,\r\n                @Inject(AUTH_SERVICE) readonly auth: IAuthService) {\r\n    }\r\n\r\n    checkRouteMenu(route: IRoute): Promise<boolean> {\r\n        if (!route.data || !route.data.name) return Promise.resolve(false);\r\n        return this.checkRoute(route);\r\n    }\r\n\r\n    checkRoute(route: IRoute, next?: ActivatedRouteSnapshot): Promise<boolean> {\r\n        const routeData = route.data || {};\r\n        if (!routeData.guards)\r\n            return Promise.resolve(!route.canActivate || this.auth.isAuthenticated);\r\n        return new Promise<boolean>(resolve => {\r\n            const guards = routeData.guards.map(g => {\r\n                const guard = ReflectUtils.resolve<RouteValidator>(g, this.injector);\r\n                return guard(this.auth, route, next);\r\n            });\r\n            Promise.all(guards).then(results => {\r\n                resolve(results.indexOf(false) < 0);\r\n            });\r\n        });\r\n    }\r\n\r\n    canActivate(next: ActivatedRouteSnapshot, state: RouterStateSnapshot): Promise<boolean> {\r\n        const route = <IRoute>next.routeConfig;\r\n        return new Promise<boolean>(resolve => {\r\n            this.auth.checkAuthenticated().then(() => {\r\n                this.checkRoute(route, next).then(hasRights => {\r\n                    resolve(hasRights);\r\n                    if (!hasRights) {\r\n                        this.getReturnState(route).then(returnState => {\r\n                            if (!returnState) return;\r\n                            this.state.navigate(returnState, {queryParams: next.queryParams});\r\n                        });\r\n                    }\r\n                });\r\n            });\r\n        });\r\n    }\r\n\r\n    getConfig(route: IRoute, config: IRoute[], path: string[]): IRoute[] {\r\n        if (!config) return null;\r\n        const match = config.findIndex(t => t == route);\r\n        if (match >= 0) return config;\r\n        for (const subConfig of config) {\r\n            if (subConfig.path)\r\n                path.push(subConfig.path);\r\n            const loadedChildren = (subConfig[\"_loadedConfig\"] || {routes: null}).routes;\r\n            const match = this.getConfig(route, subConfig.children || loadedChildren, path);\r\n            if (!match) {\r\n                if (subConfig.path)\r\n                    path.length -= 1;\r\n                continue;\r\n            }\r\n            return match;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    getReturnState(route: IRoute): Promise<string[]> {\r\n        if (!route) return Promise.resolve(null);\r\n        if (ObjectUtils.isObject(route.data) && ObjectUtils.isArray(route.data.returnState)) {\r\n            return Promise.resolve(route.data.returnState);\r\n        }\r\n        const path = [];\r\n        const config = this.getConfig(route, this.state.routerConfig, path);\r\n        return new Promise<string[]>(resolve => {\r\n            this.getReturnStateRecursive(config).then(rs => {\r\n                if (!ObjectUtils.isArray(rs)) {\r\n                    resolve(rs);\r\n                    return;\r\n                }\r\n                resolve(path.concat(rs));\r\n            });\r\n        });\r\n    }\r\n\r\n    private getReturnStateRecursive(config: IRoute[], c: number = 0): Promise<string[]> {\r\n        if (!config || c >= config.length) return Promise.resolve(null);\r\n        return new Promise<string[]>(resolve => {\r\n            const route = config[c];\r\n            const check = !route.component ? Promise.resolve(false) : this.checkRoute(route);\r\n            check.then(res => {\r\n                if (res) {\r\n                    resolve([route.path]);\r\n                    return;\r\n                }\r\n                this.getReturnStateRecursive(config, c + 1).then(resolve);\r\n            });\r\n        });\r\n    }\r\n}\r\n"]}