@stemy/ngx-utils 13.1.3 → 13.2.0

package/esm2015/ngx-utils/plugins/scroll-event.plugin.js

@@ -0,0 +1,36 @@
+import { ɵangular_packages_platform_browser_platform_browser_g as EventManagerPlugin } from "@angular/platform-browser";
+import { Inject, Injectable } from "@angular/core";
+import { DOCUMENT } from "@angular/common";
+import { UniversalService } from "../services/universal.service";
+export function emptyRemove() {
+}
+export class ScrollEventPlugin extends EventManagerPlugin {
+    constructor(doc, universal) {
+        super(doc);
+        this.universal = universal;
+    }
+    supports(eventName) {
+        return eventName === ScrollEventPlugin.EVENT_NAME;
+    }
+    addEventListener(element, eventName, handler) {
+        const zone = this.manager.getZone();
+        return zone.runOutsideAngular(() => {
+            if (this.universal.isServer)
+                return emptyRemove;
+            const callback = (e) => {
+                zone.run(() => handler(e));
+            };
+            element.addEventListener(eventName, callback);
+            return () => element.removeEventListener(eventName, callback);
+        });
+    }
+}
+ScrollEventPlugin.EVENT_NAME = "scroll";
+ScrollEventPlugin.decorators = [
+    { type: Injectable }
+];
+ScrollEventPlugin.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
+    { type: UniversalService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/ngx-utils/services/acl.service.js

@@ -0,0 +1,81 @@
+import { Inject, Injectable, Injector } from "@angular/core";
+import { StateService } from "./state.service";
+import { AUTH_SERVICE } from "../common-types";
+import { ObjectUtils } from "../utils/object.utils";
+import { AuthGuard } from "../utils/auth.guard";
+const emptyGuards = [];
+export class AclService {
+    constructor(injector, state, auth) {
+        this.injector = injector;
+        this.state = state;
+        this.auth = auth;
+        this.components = [];
+        this.auth.userChanged.subscribe(() => {
+            this.components.forEach(t => t.dirty = true);
+            const info = this.getStateInfo();
+            const check = info && info.guard instanceof AuthGuard ? info.guard.checkRoute(info.route) : Promise.resolve(true);
+            check.then(result => {
+                if (result) {
+                    if (!info || !info.dirty)
+                        return;
+                    info.dirty = false;
+                    const component = info.component;
+                    if (!info.component)
+                        return;
+                    if (info.first) {
+                        if (ObjectUtils.isFunction(component.onUserInitialized)) {
+                            component.onUserInitialized();
+                        }
+                        info.first = false;
+                        return;
+                    }
+                    if (ObjectUtils.isFunction(component.onUserChanged)) {
+                        component.onUserChanged();
+                    }
+                    return;
+                }
+                info.guard.getReturnState(info.route).then(returnState => {
+                    if (!returnState)
+                        return;
+                    this.state.navigate(returnState);
+                });
+            });
+        });
+        this.state.subscribe(() => {
+            const info = this.getStateInfo();
+            if (!(info === null || info === void 0 ? void 0 : info.component))
+                return;
+            const component = info.component;
+            if (ObjectUtils.isFunction(component.onUserInitialized)) {
+                component.onUserInitialized();
+            }
+        });
+    }
+    getStateInfo() {
+        const route = this.state.route;
+        if (!route)
+            return null;
+        let info = this.components.find(t => t.route == this.state.route);
+        if (!info) {
+            const guardType = (route.canActivate || emptyGuards)[0];
+            info = {
+                route: this.state.route,
+                guard: guardType ? this.injector.get(guardType) : null,
+                dirty: true,
+                first: true
+            };
+            this.components.push(info);
+        }
+        info.component = this.state.component;
+        return info;
+    }
+}
+AclService.decorators = [
+    { type: Injectable }
+];
+AclService.ctorParameters = () => [
+    { type: Injector },
+    { type: StateService },
+    { type: undefined, decorators: [{ type: Inject, args: [AUTH_SERVICE,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/ngx-utils/services/api.service.js

@@ -0,0 +1,35 @@
+import { Injectable } from "@angular/core";
+import { BaseHttpService } from "./base-http.service";
+export class ApiService extends BaseHttpService {
+    get name() {
+        return "api";
+    }
+    url(url) {
+        return this.expressRequestUrl(`/api/${url}`);
+    }
+    get(url, options, body) {
+        return this.getPromise(url, options, body);
+    }
+    delete(url, options, body) {
+        return this.deletePromise(url, options, body);
+    }
+    post(url, body, options) {
+        return this.postPromise(url, body, options);
+    }
+    put(url, body, options) {
+        return this.putPromise(url, body, options);
+    }
+    patch(url, body, options) {
+        return this.patchPromise(url, body, options);
+    }
+    upload(url, body, listener, options) {
+        return this.uploadPromise(url, body, listener, options);
+    }
+    list(url, params) {
+        return this.listPromise(url, params);
+    }
+}
+ApiService.decorators = [
+    { type: Injectable }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/ngx-utils/services/auth.service.js

@@ -0,0 +1,14 @@
+import { EventEmitter } from "@angular/core";
+export class StaticAuthService {
+    constructor() {
+        this.isAuthenticated = true;
+        this.userChanged = new EventEmitter();
+    }
+    checkAuthenticated() {
+        return Promise.resolve(this.isAuthenticated);
+    }
+    getReturnState(route) {
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL25neC11dGlscy9zZXJ2aWNlcy9hdXRoLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUczQyxNQUFNLE9BQU8saUJBQWlCO0lBQTlCO1FBRUksb0JBQWUsR0FBWSxJQUFJLENBQUM7UUFDaEMsZ0JBQVcsR0FBc0IsSUFBSSxZQUFZLEVBQU8sQ0FBQztJQVM3RCxDQUFDO0lBUEcsa0JBQWtCO1FBQ2QsT0FBTyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsQ0FBQztJQUNqRCxDQUFDO0lBRUQsY0FBYyxDQUFDLEtBQWE7UUFDeEIsT0FBTyxJQUFJLENBQUM7SUFDaEIsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtFdmVudEVtaXR0ZXJ9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7SVJvdXRlLCBJQXV0aFNlcnZpY2V9IGZyb20gXCIuLi9jb21tb24tdHlwZXNcIjtcclxuXHJcbmV4cG9ydCBjbGFzcyBTdGF0aWNBdXRoU2VydmljZSBpbXBsZW1lbnRzIElBdXRoU2VydmljZSB7XHJcblxyXG4gICAgaXNBdXRoZW50aWNhdGVkOiBib29sZWFuID0gdHJ1ZTtcclxuICAgIHVzZXJDaGFuZ2VkOiBFdmVudEVtaXR0ZXI8YW55PiA9IG5ldyBFdmVudEVtaXR0ZXI8YW55PigpO1xyXG5cclxuICAgIGNoZWNrQXV0aGVudGljYXRlZCgpOiBQcm9taXNlPGJvb2xlYW4+IHtcclxuICAgICAgICByZXR1cm4gUHJvbWlzZS5yZXNvbHZlKHRoaXMuaXNBdXRoZW50aWNhdGVkKTtcclxuICAgIH1cclxuXHJcbiAgICBnZXRSZXR1cm5TdGF0ZShyb3V0ZTogSVJvdXRlKTogc3RyaW5nW10ge1xyXG4gICAgICAgIHJldHVybiBudWxsO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2015/ngx-utils/services/base-http.client.js

@@ -0,0 +1,46 @@
+import { Injectable } from "@angular/core";
+import { HttpClient, HttpHandler, HttpHeaders, HttpParams, HttpUrlEncodingCodec } from "@angular/common/http";
+import { ObjectUtils } from "../utils/object.utils";
+export class BaseHttpClient extends HttpClient {
+    constructor(handler) {
+        super(handler);
+        this.requestHeaders = {};
+        this.requestParams = {};
+        this.extraRequestParams = {
+            language: "en"
+        };
+    }
+    makeHeaders(headers, withCredentials = true) {
+        headers = Object.assign({}, this.requestHeaders, headers);
+        const authHeader = headers["Authorization"] || "";
+        if (!withCredentials && !authHeader.startsWith("Bearer")) {
+            delete headers["Authorization"];
+        }
+        return new HttpHeaders(headers);
+    }
+    makeParams(params) {
+        params = Object.assign({}, this.extraRequestParams, this.requestParams, params);
+        return new HttpParams({
+            encoder: new HttpUrlEncodingCodec(),
+            fromObject: Object.keys(params || {}).reduce((result, key) => {
+                const value = params[key];
+                result[key] = ObjectUtils.isObject(value) ? JSON.stringify(value) : (ObjectUtils.isNullOrUndefined(value) ? "" : value.toString());
+                return result;
+            }, {})
+        });
+    }
+    setExtraRequestParam(name, value) {
+        if (typeof value == "undefined") {
+            delete this.extraRequestParams[name];
+            return;
+        }
+        this.extraRequestParams[name] = value;
+    }
+}
+BaseHttpClient.decorators = [
+    { type: Injectable }
+];
+BaseHttpClient.ctorParameters = () => [
+    { type: HttpHandler }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/ngx-utils/services/base-http.service.js

@@ -0,0 +1,285 @@
+import { __awaiter } from "tslib";
+import { Inject, Injectable, Optional } from "@angular/core";
+import { HttpEventType } from "@angular/common/http";
+import { CONFIG_SERVICE, EXPRESS_REQUEST, HttpPromise, LANGUAGE_SERVICE, TOASTER_SERVICE } from "../common-types";
+import { ObjectUtils } from "../utils/object.utils";
+import { MathUtils } from "../utils/math.utils";
+import { BaseHttpClient } from "./base-http.client";
+import { StorageService } from "./storage.service";
+import { timeout } from "rxjs/operators";
+import { TimeoutError } from "rxjs";
+export class BaseHttpService {
+    constructor(client, storage, language, toaster, configs, request = null) {
+        this.client = client;
+        this.storage = storage;
+        this.language = language;
+        this.toaster = toaster;
+        this.configs = configs;
+        this.request = request;
+        this.requestHeaders = {};
+        this.requestParams = {};
+        this.cache = {};
+    }
+    get name() {
+        return "base";
+    }
+    get withCredentials() {
+        return true;
+    }
+    static retryFailedRequests() {
+        BaseHttpService.failedRequests.forEach(r => r());
+        BaseHttpService.failedRequests = [];
+    }
+    get universal() {
+        return this.storage.universal;
+    }
+    url(url) {
+        return url;
+    }
+    createUrl(url, params) {
+        const httpParams = this.client.makeParams(params);
+        const query = httpParams.keys().map(key => {
+            return `${key}=${httpParams.get(key)}`;
+        }).join("&");
+        return `${this.url(url)}?${query}`;
+    }
+    makeListParams(page, itemsPerPage, orderBy = null, orderDescending = null, filter = null) {
+        const params = {
+            page: (page - 1),
+            limit: itemsPerPage
+        };
+        if (!ObjectUtils.isNullOrUndefined(orderBy) && !ObjectUtils.isNullOrUndefined(orderDescending)) {
+            params.sort = `${orderDescending ? "-" : ""}${orderBy}`;
+        }
+        if (!ObjectUtils.isNullOrUndefined(filter)) {
+            params.filter = filter;
+        }
+        return params;
+    }
+    getPromise(url, options, body) {
+        options = this.makeOptions(options, "GET", body);
+        return this.toPromise(url, options);
+    }
+    deletePromise(url, options, body) {
+        options = this.makeOptions(options, "DELETE", body);
+        return this.toPromise(url, options);
+    }
+    postPromise(url, body, options) {
+        options = this.makeOptions(options, "POST", body);
+        return this.toPromise(url, options);
+    }
+    putPromise(url, body, options) {
+        options = this.makeOptions(options, "PUT", body);
+        return this.toPromise(url, options);
+    }
+    patchPromise(url, body, options) {
+        options = this.makeOptions(options, "PATCH", body);
+        return this.toPromise(url, options);
+    }
+    uploadPromise(url, body, listener, options) {
+        const headers = {};
+        if (body instanceof Blob) {
+            headers["Content-Type"] = "application/octet-stream";
+        }
+        options = this.makeOptions(Object.assign({
+            headers: headers,
+            reportProgress: true
+        }, options), "POST", body);
+        return this.toPromise(url, options, listener);
+    }
+    listPromise(url, params) {
+        return new Promise(resolve => {
+            this.getPromise(url, { params: params }).then(data => {
+                var _a, _b;
+                if (ObjectUtils.isArray(data)) {
+                    resolve({
+                        total: data.length,
+                        items: data,
+                        meta: {}
+                    });
+                    return;
+                }
+                resolve({
+                    total: ((_a = data.meta) === null || _a === void 0 ? void 0 : _a.total) || (data === null || data === void 0 ? void 0 : data.total) || ((_b = data.items) === null || _b === void 0 ? void 0 : _b.length) || 0,
+                    items: data.items || [],
+                    meta: data.meta || {}
+                });
+            }, response => {
+                if (response.status == 0 || response.status == 301) {
+                    resolve({
+                        total: 1,
+                        items: [{
+                                id: null,
+                                label: "Not implemented."
+                            }],
+                        meta: {}
+                    });
+                    return true;
+                }
+                resolve({
+                    total: 0,
+                    items: [],
+                    meta: {}
+                });
+                return false;
+            });
+        });
+    }
+    handleUnauthorizedError(absoluteUrl, options, reject) {
+        reject();
+        if (BaseHttpService.failedRequests.length > 1) {
+            return;
+        }
+        if (this.universal.isServer)
+            return;
+        console.log("User auth error", absoluteUrl, options);
+    }
+    toastWarning(message, issueContext, reason, options) {
+        this.toaster.warning(message, { issueContext, reason, options });
+    }
+    toastError(message, issueContext, reason, options) {
+        this.toaster.warning(message, { issueContext, reason, options });
+    }
+    toPromise(url, options, listener) {
+        const issueContext = { url: "" };
+        return new HttpPromise(response => {
+            if (!response) {
+                if (this.universal.isServer)
+                    return;
+                console.log("You may not need a reject Handler for this request!", this.name, url, options);
+                return;
+            }
+            const reason = response.error || {};
+            if (response.status == 0 || response.status == 301) {
+                this.toastWarning(`${url} endpoint is not implemented! Click here, to quickly create an issue.`, issueContext, reason, options);
+                return;
+            }
+            const regex = /((E11000 duplicate key error collection: (.)+\.)|(_1 dup key:(.)+))/g;
+            if (reason.message && regex.test(reason.message)) {
+                this.toastError("message.duplicate-key.error." + reason.message.replace(regex, "").replace(" index: ", "-"), issueContext, reason, options);
+                return;
+            }
+            this.toastWarning(`${url} endpoint error is not handled properly! Click here, to quickly create an issue.`, issueContext, reason, options);
+        }, (resolve, reject) => {
+            this.absoluteUrl(url, options).then(absoluteUrl => {
+                issueContext.url = absoluteUrl;
+                const request = this.client.request(options.method, absoluteUrl, options);
+                const finalRequest = ObjectUtils.isNumber(options.timeout) && options.timeout > 0
+                    ? request.pipe(timeout(options.timeout)) : request;
+                finalRequest.subscribe((event) => {
+                    if (options.reportProgress && event.type === HttpEventType.UploadProgress) {
+                        const progress = {
+                            percentage: MathUtils.round(event.loaded / event.total, 2, 0.01),
+                            loaded: event.loaded,
+                            total: event.total
+                        };
+                        if (listener) {
+                            listener(progress);
+                        }
+                        return;
+                    }
+                    resolve(this.parseResponse(event, url, options));
+                    const headers = options.headers;
+                    const authKey = "Authorization";
+                    // If we use token auth
+                    if (this.client.renewTokenFunc && headers.has(authKey)) {
+                        const currentTime = new Date().getTime();
+                        const userTokenTime = this.storage.get("userTokenTime") || currentTime;
+                        // And the last request was a long long time ago
+                        if (currentTime - 600000 > userTokenTime) {
+                            this.client.renewTokenFunc();
+                        }
+                    }
+                }, (response) => {
+                    if (response instanceof TimeoutError || response.status == 0 || response.status == 301) {
+                        reject(response);
+                        return;
+                    }
+                    const headers = options.headers;
+                    const authKey = "Authorization";
+                    // If an authorization header exists and we still have an Unauthorized response prompt the user to log in again
+                    if (headers.has(authKey) && response.status == 401) {
+                        const pushed = this.pushFailedRequest(url, options, () => {
+                            options.headers = this.makeHeaders(options.originalHeaders);
+                            this.toPromise(url, options, listener).then(resolve, reject);
+                        });
+                        if (pushed)
+                            this.handleUnauthorizedError(absoluteUrl, options, () => reject(response));
+                        return;
+                    }
+                    reject(response);
+                });
+            });
+        });
+    }
+    pushFailedRequest(url, options, req) {
+        if (url.indexOf("tokens") >= 0)
+            return false;
+        BaseHttpService.failedRequests.push(req);
+        return true;
+    }
+    checkHeaders(headers) {
+        if (!headers || !headers.cookie || !headers.referer || !headers.host) {
+            return false;
+        }
+        return headers.referer.indexOf(headers.host) >= 0;
+    }
+    makeOptions(options, method = "GET", body) {
+        // Set base options
+        options = options ? Object.assign({}, options) : {};
+        options.method = method;
+        options.observe = options.observe || "body";
+        options.originalHeaders = options.originalHeaders || options.headers || {};
+        options.withCredentials = ObjectUtils.isBoolean(options.withCredentials) ? options.withCredentials : this.withCredentials;
+        options.body = body || {};
+        // Set cookies from server side request
+        const headers = !this.request ? null : this.request.headers;
+        if (this.checkHeaders(headers)) {
+            options.headers["Cookie"] = headers.cookie;
+        }
+        options.headers = this.makeHeaders(options);
+        options.params = this.makeParams(options);
+        return options;
+    }
+    makeHeaders(options) {
+        return this.client.makeHeaders(Object.assign({}, this.requestHeaders, (options === null || options === void 0 ? void 0 : options.headers) || {}));
+    }
+    makeParams(options) {
+        return this.client.makeParams(Object.assign({}, this.requestParams, (options === null || options === void 0 ? void 0 : options.params) || {}));
+    }
+    parseResponse(response, url, options) {
+        return response;
+    }
+    parseUrl(url) {
+        return this.url(url).replace(/(?:((?!:).\/)\/)/g, "$1");
+    }
+    absoluteUrl(url, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const absoluteUrl = this.parseUrl(url);
+            if (url == "api-docs") {
+                return absoluteUrl.replace("/api", "");
+            }
+            return absoluteUrl;
+        });
+    }
+    expressRequestUrl(url) {
+        const req = this.request;
+        if (!req || !url || url.startsWith("http") || url.startsWith("//"))
+            return url;
+        const separator = url.startsWith("/") ? "" : "/";
+        return `${req.protocol}://${req.get("host")}${separator}${url}`;
+    }
+}
+BaseHttpService.failedRequests = [];
+BaseHttpService.decorators = [
+    { type: Injectable }
+];
+BaseHttpService.ctorParameters = () => [
+    { type: BaseHttpClient, decorators: [{ type: Inject, args: [BaseHttpClient,] }] },
+    { type: StorageService, decorators: [{ type: Inject, args: [StorageService,] }] },
+    { type: undefined, decorators: [{ type: Inject, args: [LANGUAGE_SERVICE,] }] },
+    { type: undefined, decorators: [{ type: Inject, args: [TOASTER_SERVICE,] }] },
+    { type: undefined, decorators: [{ type: Inject, args: [CONFIG_SERVICE,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [EXPRESS_REQUEST,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-http.service.js","sourceRoot":"","sources":["../../../../src/ngx-utils/services/base-http.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, Optional} from \"@angular/core\";\r\nimport {HttpErrorResponse, HttpEventType, HttpHeaders, HttpParams, HttpResponse} from \"@angular/common/http\";\r\nimport {Request} from \"express\";\r\n\r\nimport {\r\n    CONFIG_SERVICE,\r\n    EXPRESS_REQUEST,\r\n    HttpPromise,\r\n    IConfigService,\r\n    IHttpHeaders,\r\n    IHttpParams,\r\n    IHttpService,\r\n    IIssueContext,\r\n    ILanguageService,\r\n    IPaginationData,\r\n    IRequestOptions,\r\n    IToasterService,\r\n    LANGUAGE_SERVICE,\r\n    ProgressListener,\r\n    TOASTER_SERVICE\r\n} from \"../common-types\";\r\n\r\nimport {ObjectUtils} from \"../utils/object.utils\";\r\nimport {MathUtils} from \"../utils/math.utils\";\r\n\r\nimport {BaseHttpClient} from \"./base-http.client\";\r\nimport {UniversalService} from \"./universal.service\";\r\nimport {StorageService} from \"./storage.service\";\r\nimport {timeout} from \"rxjs/operators\";\r\nimport {TimeoutError} from \"rxjs\";\r\n\r\n@Injectable()\r\nexport class BaseHttpService implements IHttpService {\r\n\r\n    protected static failedRequests: Array<() => void> = [];\r\n\r\n    get name(): string {\r\n        return \"base\";\r\n    }\r\n\r\n    protected get withCredentials(): boolean {\r\n        return true;\r\n    }\r\n\r\n    requestHeaders: IHttpHeaders;\r\n    requestParams: IHttpParams;\r\n    cache: any;\r\n\r\n    protected static retryFailedRequests(): void {\r\n        BaseHttpService.failedRequests.forEach(r => r());\r\n        BaseHttpService.failedRequests = [];\r\n    }\r\n\r\n    get universal(): UniversalService {\r\n        return this.storage.universal;\r\n    }\r\n\r\n    constructor(@Inject(BaseHttpClient) readonly client: BaseHttpClient,\r\n                @Inject(StorageService) readonly storage: StorageService,\r\n                @Inject(LANGUAGE_SERVICE) readonly language: ILanguageService,\r\n                @Inject(TOASTER_SERVICE) readonly toaster: IToasterService,\r\n                @Inject(CONFIG_SERVICE) readonly configs: IConfigService,\r\n                @Optional() @Inject(EXPRESS_REQUEST) readonly request: Request = null\r\n    ) {\r\n        this.requestHeaders = {};\r\n        this.requestParams = {};\r\n        this.cache = {};\r\n    }\r\n\r\n    url(url: string): string {\r\n        return url;\r\n    }\r\n\r\n    createUrl(url: string, params: IHttpParams): string {\r\n        const httpParams = this.client.makeParams(params);\r\n        const query = httpParams.keys().map(key => {\r\n            return `${key}=${httpParams.get(key)}`;\r\n        }).join(\"&\");\r\n        return `${this.url(url)}?${query}`;\r\n    }\r\n\r\n    makeListParams(page: number, itemsPerPage: number, orderBy: string = null, orderDescending: boolean = null, filter: string = null): IHttpParams {\r\n        const params: IHttpParams = {\r\n            page: (page - 1),\r\n            limit: itemsPerPage\r\n        };\r\n        if (!ObjectUtils.isNullOrUndefined(orderBy) && !ObjectUtils.isNullOrUndefined(orderDescending)) {\r\n            params.sort = `${orderDescending ? \"-\" : \"\"}${orderBy}`;\r\n        }\r\n        if (!ObjectUtils.isNullOrUndefined(filter)) {\r\n            params.filter = filter;\r\n        }\r\n        return params;\r\n    }\r\n\r\n    protected getPromise(url: string, options?: IRequestOptions, body?: any): HttpPromise {\r\n        options = this.makeOptions(options, \"GET\", body);\r\n        return this.toPromise(url, options);\r\n    }\r\n\r\n    protected deletePromise(url: string, options?: IRequestOptions, body?: any): HttpPromise {\r\n        options = this.makeOptions(options, \"DELETE\", body);\r\n        return this.toPromise(url, options);\r\n    }\r\n\r\n    protected postPromise(url: string, body?: any, options?: IRequestOptions): HttpPromise {\r\n        options = this.makeOptions(options, \"POST\", body);\r\n        return this.toPromise(url, options);\r\n    }\r\n\r\n    protected putPromise(url: string, body?: any, options?: IRequestOptions): HttpPromise {\r\n        options = this.makeOptions(options, \"PUT\", body);\r\n        return this.toPromise(url, options);\r\n    }\r\n\r\n    protected patchPromise(url: string, body?: any, options?: IRequestOptions): HttpPromise {\r\n        options = this.makeOptions(options, \"PATCH\", body);\r\n        return this.toPromise(url, options);\r\n    }\r\n\r\n    protected uploadPromise(url: string, body: any, listener?: ProgressListener, options?: IRequestOptions): HttpPromise {\r\n        const headers: any = {};\r\n        if (body instanceof Blob) {\r\n            headers[\"Content-Type\"] = \"application/octet-stream\";\r\n        }\r\n        options = this.makeOptions(Object.assign({\r\n            headers: headers,\r\n            reportProgress: true\r\n        }, options), \"POST\", body);\r\n        return this.toPromise(url, options, listener);\r\n    }\r\n\r\n    protected listPromise(url: string, params: IHttpParams): Promise<IPaginationData> {\r\n        return new Promise<IPaginationData>(resolve => {\r\n            this.getPromise(url, {params: params}).then(data => {\r\n                if (ObjectUtils.isArray(data)) {\r\n                    resolve({\r\n                        total: data.length,\r\n                        items: data,\r\n                        meta: {}\r\n                    });\r\n                    return;\r\n                }\r\n                resolve({\r\n                    total: data.meta?.total || data?.total || data.items?.length || 0,\r\n                    items: data.items || [],\r\n                    meta: data.meta || {}\r\n                });\r\n            }, response => {\r\n                if (response.status == 0 || response.status == 301) {\r\n                    resolve({\r\n                        total: 1,\r\n                        items: [{\r\n                            id: null,\r\n                            label: \"Not implemented.\"\r\n                        }],\r\n                        meta: {}\r\n                    });\r\n                    return true;\r\n                }\r\n                resolve({\r\n                    total: 0,\r\n                    items: [],\r\n                    meta: {}\r\n                });\r\n                return false;\r\n            });\r\n        });\r\n    }\r\n\r\n    protected handleUnauthorizedError(absoluteUrl: string, options: IRequestOptions, reject: () => void): void {\r\n        reject();\r\n        if (BaseHttpService.failedRequests.length > 1) {\r\n            return;\r\n        }\r\n        if (this.universal.isServer) return;\r\n        console.log(\"User auth error\", absoluteUrl, options);\r\n    }\r\n\r\n    protected toastWarning(message: string, issueContext: IIssueContext, reason: any, options: IRequestOptions): void {\r\n        this.toaster.warning(message, {issueContext, reason, options});\r\n    }\r\n\r\n    protected toastError(message: string, issueContext: IIssueContext, reason: any, options: IRequestOptions): void {\r\n        this.toaster.warning(message, {issueContext, reason, options});\r\n    }\r\n\r\n    protected toPromise(url: string, options: IRequestOptions, listener?: ProgressListener): HttpPromise {\r\n        const issueContext: IIssueContext = {url: \"\"};\r\n\r\n        return new HttpPromise(response => {\r\n            if (!response) {\r\n                if (this.universal.isServer) return;\r\n                console.log(\"You may not need a reject Handler for this request!\", this.name, url, options);\r\n                return;\r\n            }\r\n            const reason = response.error || {};\r\n            if (response.status == 0 || response.status == 301) {\r\n                this.toastWarning(`${url} endpoint is not implemented! Click here, to quickly create an issue.`, issueContext, reason, options);\r\n                return;\r\n            }\r\n            const regex = /((E11000 duplicate key error collection: (.)+\\.)|(_1 dup key:(.)+))/g;\r\n            if (reason.message && regex.test(reason.message)) {\r\n                this.toastError(\"message.duplicate-key.error.\" + reason.message.replace(regex, \"\").replace(\" index: \", \"-\"), issueContext, reason, options);\r\n                return;\r\n            }\r\n            this.toastWarning(`${url} endpoint error is not handled properly! Click here, to quickly create an issue.`, issueContext, reason, options);\r\n        }, (resolve, reject) => {\r\n            this.absoluteUrl(url, options).then(absoluteUrl => {\r\n                issueContext.url = absoluteUrl;\r\n                const request = this.client.request(options.method, absoluteUrl, options);\r\n                const finalRequest = ObjectUtils.isNumber(options.timeout) && options.timeout > 0\r\n                    ? request.pipe(timeout(options.timeout)) : request;\r\n                finalRequest.subscribe((event: any) => {\r\n                    if (options.reportProgress && event.type === HttpEventType.UploadProgress) {\r\n                        const progress = {\r\n                            percentage: MathUtils.round(event.loaded / event.total, 2, 0.01),\r\n                            loaded: event.loaded,\r\n                            total: event.total\r\n                        };\r\n                        if (listener) {\r\n                            listener(progress);\r\n                        }\r\n                        return;\r\n                    }\r\n                    resolve(this.parseResponse(event, url, options));\r\n                    const headers = options.headers as HttpHeaders;\r\n                    const authKey = \"Authorization\";\r\n                    // If we use token auth\r\n                    if (this.client.renewTokenFunc && headers.has(authKey)) {\r\n                        const currentTime = new Date().getTime();\r\n                        const userTokenTime = this.storage.get(\"userTokenTime\") || currentTime;\r\n                        // And the last request was a long long time ago\r\n                        if (currentTime - 600000 > userTokenTime) {\r\n                            this.client.renewTokenFunc();\r\n                        }\r\n                    }\r\n                }, (response: HttpErrorResponse | TimeoutError) => {\r\n                    if (response instanceof TimeoutError || response.status == 0 || response.status == 301) {\r\n                        reject(response);\r\n                        return;\r\n                    }\r\n                    const headers = options.headers as HttpHeaders;\r\n                    const authKey = \"Authorization\";\r\n                    // If an authorization header exists and we still have an Unauthorized response prompt the user to log in again\r\n                    if (headers.has(authKey) && response.status == 401) {\r\n                        const pushed = this.pushFailedRequest(url, options, () => {\r\n                            options.headers = this.makeHeaders(options.originalHeaders);\r\n                            this.toPromise(url, options, listener).then(resolve, reject);\r\n                        });\r\n                        if (pushed)\r\n                            this.handleUnauthorizedError(absoluteUrl, options, () => reject(response));\r\n                        return;\r\n                    }\r\n                    reject(response);\r\n                });\r\n            });\r\n        });\r\n    }\r\n\r\n    protected pushFailedRequest(url: string, options: IRequestOptions, req: () => void): boolean {\r\n        if (url.indexOf(\"tokens\") >= 0) return false;\r\n        BaseHttpService.failedRequests.push(req);\r\n        return true;\r\n    }\r\n\r\n    protected checkHeaders(headers: any): boolean {\r\n        if (!headers || !headers.cookie || !headers.referer || !headers.host) {\r\n            return false;\r\n        }\r\n        return headers.referer.indexOf(headers.host) >= 0;\r\n    }\r\n\r\n    protected makeOptions(options?: IRequestOptions, method: string = \"GET\", body?: any): IRequestOptions {\r\n        // Set base options\r\n        options = options ? {...options} : {};\r\n        options.method = method;\r\n        options.observe = options.observe || \"body\";\r\n        options.originalHeaders = options.originalHeaders || (options.headers as IHttpHeaders) || {};\r\n        options.withCredentials = ObjectUtils.isBoolean(options.withCredentials) ? options.withCredentials : this.withCredentials;\r\n        options.body = body || {};\r\n        // Set cookies from server side request\r\n        const headers = !this.request ? null : this.request.headers;\r\n        if (this.checkHeaders(headers)) {\r\n            options.headers[\"Cookie\"] = headers.cookie;\r\n        }\r\n        options.headers = this.makeHeaders(options);\r\n        options.params = this.makeParams(options);\r\n        return options;\r\n    }\r\n\r\n    protected makeHeaders(options: IRequestOptions): HttpHeaders {\r\n        return this.client.makeHeaders(Object.assign({}, this.requestHeaders, options?.headers || {}));\r\n    }\r\n\r\n    protected makeParams(options: IRequestOptions): HttpParams {\r\n        return this.client.makeParams(Object.assign({}, this.requestParams, options?.params || {}));\r\n    }\r\n\r\n    protected parseResponse(response: any, url: string, options: IRequestOptions): any {\r\n        return response;\r\n    }\r\n\r\n    protected parseUrl(url: string): string {\r\n        return this.url(url).replace(/(?:((?!:).\\/)\\/)/g, \"$1\");\r\n    }\r\n\r\n    protected async absoluteUrl(url: string, options: IRequestOptions): Promise<string> {\r\n        const absoluteUrl = this.parseUrl(url);\r\n        if (url == \"api-docs\") {\r\n            return absoluteUrl.replace(\"/api\", \"\");\r\n        }\r\n        return absoluteUrl;\r\n    }\r\n\r\n    protected expressRequestUrl(url: string): string {\r\n        const req = this.request;\r\n        if (!req || !url || url.startsWith(\"http\") || url.startsWith(\"//\")) return url;\r\n        const separator = url.startsWith(\"/\") ? \"\" : \"/\";\r\n        return `${req.protocol}://${req.get(\"host\")}${separator}${url}`;\r\n    }\r\n}\r\n"]}