@vgip/meta-ui 1.1.3

package/esm2015/lib/services/metaContext/index.js

@@ -0,0 +1,34 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2019-09-19 17:35:19
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2020-03-06 10:10:09
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MetaContextService {
+    constructor() {
+        this.defaultContactables = {};
+        this.workers = {};
+        this.contactables = {};
+        this.profiles = {};
+    }
+    set(context) {
+        if (context) {
+            if (context.phoneNumber) {
+                this.phoneNumber = context.phoneNumber;
+            }
+            if (context.displayName) {
+                this.displayName = context.displayName;
+            }
+        }
+    }
+}
+MetaContextService.ɵprov = i0.ɵɵdefineInjectable({ factory: function MetaContextService_Factory() { return new MetaContextService(); }, token: MetaContextService, providedIn: "root" });
+MetaContextService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+MetaContextService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/metaMsg/index.js

@@ -0,0 +1,86 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2019-09-19 17:35:19
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2020-05-03 21:31:16
+ */
+/*
+* Worker messages systems. Every integration may extend the base functionality by registering an integration worker.
+* This service provides single response for the worker message requests as a callback.
+*/
+import { Injectable } from '@angular/core';
+import { MetaContextService } from '../metaContext';
+import * as i0 from "@angular/core";
+import * as i1 from "../metaContext/index";
+export class MetaMsgService {
+    constructor(metaContext) {
+        this.metaContext = metaContext;
+        this.msgCallbacks = {}; // message subscribers holder
+        this.msgListeneres = []; // ensure listener is registerd only once
+        this.workerMsgListener = (msg) => {
+            if (msg && msg.data && msg.data.action && msg.data.$state) {
+                const state = msg.data.$state;
+                const callback = this.msgCallbacks[state]; // original requester callback
+                if (callback) {
+                    delete msg.data.$state;
+                    callback(msg.data);
+                }
+                delete this.msgCallbacks[state]; // get rid of the listener callback when done
+            }
+            this.removeExpiredListeners(); // wipe out the expired listeners if any
+        };
+    }
+    sendMessage(provider, msg, callback, isLong = false) {
+        provider = (provider || '').toUpperCase();
+        const providerWorker = this.metaContext.workers[provider];
+        if (providerWorker) {
+            if (this.msgListeneres.indexOf(provider)) {
+                this.msgListeneres.push(provider);
+                providerWorker.addEventListener('message', this.workerMsgListener, false); // register a short time listener
+            }
+            let state; // message unique identifier
+            do {
+                state = new Date().getTime();
+            } while (!!this.msgCallbacks[state]);
+            this.msgCallbacks[state] = callback; // register message callback
+            msg.$state = state;
+            providerWorker.postMessage(msg);
+            setTimeout(() => {
+                this.cancelMsgListener(msg.action, state); // give up, worker does not replied on time
+                const listenerIndex = this.msgListeneres.indexOf(provider);
+                if (listenerIndex !== -1) {
+                    this.msgListeneres.splice(listenerIndex, 1);
+                }
+                providerWorker.removeEventListener('message', this.workerMsgListener); // remove listener when done
+            }, isLong ? 60000 : 2000);
+        }
+        else {
+            callback({ action: msg.action, error: `Worker ${provider} is not registered` });
+        }
+    }
+    cancelMsgListener(action, storedState) {
+        const storedCallback = this.msgCallbacks[storedState];
+        if (storedCallback) {
+            storedCallback({ action, error: 'Timeout', state: storedState }); // always reply with something
+        }
+        delete this.msgCallbacks[storedState];
+    }
+    removeExpiredListeners() {
+        const now = new Date();
+        for (const state in this.msgCallbacks) { // cleanup expired listeners (< 1 min ago);
+            if (parseInt(state, 10) < now.setMinutes(now.getMinutes() - 1)) {
+                delete this.msgCallbacks[state];
+            }
+        }
+    }
+}
+MetaMsgService.ɵprov = i0.ɵɵdefineInjectable({ factory: function MetaMsgService_Factory() { return new MetaMsgService(i0.ɵɵinject(i1.MetaContextService)); }, token: MetaMsgService, providedIn: "root" });
+MetaMsgService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+MetaMsgService.ctorParameters = () => [
+    { type: MetaContextService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/metaReference/index.js

@@ -0,0 +1,98 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2019-09-19 17:35:19
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2020-05-03 21:31:44
+ */
+import { Injectable, ApplicationRef, Injector } from '@angular/core';
+import { Router } from '@angular/router';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class MetaReferenceService {
+    constructor(appRef, injector, router) {
+        this.appRef = appRef;
+        this.injector = injector;
+        this.router = router;
+        this.dialogs = [];
+        this.router.events.subscribe((e) => {
+            if (this.dialogs.length) {
+                for (let d = (this.dialogs.length - 1); d >= 0; d--) {
+                    this.dialogs[d].onComplete();
+                }
+            }
+        });
+    }
+    openDialog(refDialogFactory, metaResource, integrationCode, reference, resource, preview, preferResourceType, theme) {
+        const references = !(reference instanceof Array) ? [reference] : reference.filter((r) => r.creatable !== false);
+        if (resource && resource.type) {
+            if (!references.find((f) => (f.name || f.resourceType) === (resource.resourceType || resource.type))) {
+                references.push({
+                    name: resource.resourceType || resource.type,
+                    resourceType: resource.resourceType || resource.type,
+                    label: resource.label || resource.resourceType || resource.type
+                });
+            }
+        }
+        const modalObservable = new Observable(observer => {
+            const componentRef = refDialogFactory.create(this.injector);
+            this.appRef.attachView(componentRef.hostView);
+            const refDialog = componentRef.instance;
+            refDialog.integrationCode = integrationCode;
+            refDialog.reference = references;
+            refDialog.resource = resource;
+            refDialog.metaResource = metaResource;
+            refDialog.edit = !preview;
+            refDialog.preferResourceType = preferResourceType;
+            refDialog.theme = theme;
+            const domElem = componentRef.hostView.rootNodes[0];
+            const dialogIndex = this.dialogs.push(refDialog);
+            if (dialogIndex > 1) {
+                const modalPanel = domElem.querySelector('.Vlt-modal__panel');
+                if (modalPanel) {
+                    modalPanel.style.marginLeft = `${(dialogIndex * 5)}px`;
+                    modalPanel.style.marginTop = `${(dialogIndex * 10)}px`;
+                    modalPanel.style.marginBottom = `${((dialogIndex - 1) * 8)}px`;
+                }
+            }
+            document.body.appendChild(domElem);
+            refDialog.onComplete = (result) => {
+                if (result) {
+                    /* eslint-disable no-underscore-dangle */
+                    if (result._vgis) {
+                        observer.next({
+                            id: result._vgis.externalId || result._vgis.id,
+                            label: result._vgis.label,
+                            type: result._vgis.resourceType,
+                            raw: result
+                        });
+                    }
+                    else {
+                        console.log('onComplete non VGIS result', result);
+                    }
+                    /* eslint-enable no-underscore-dangle */
+                }
+                else {
+                    observer.next();
+                }
+                observer.complete();
+                this.appRef.detachView(componentRef.hostView);
+                componentRef.destroy();
+                this.dialogs.splice(dialogIndex - 1, 1);
+            };
+        });
+        return modalObservable;
+    }
+}
+MetaReferenceService.ɵprov = i0.ɵɵdefineInjectable({ factory: function MetaReferenceService_Factory() { return new MetaReferenceService(i0.ɵɵinject(i0.ApplicationRef), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i1.Router)); }, token: MetaReferenceService, providedIn: "root" });
+MetaReferenceService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+MetaReferenceService.ctorParameters = () => [
+    { type: ApplicationRef },
+    { type: Injector },
+    { type: Router }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../projects/meta-ui/src/lib/services/metaReference/index.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * @Author: Alexander.Vangelov@vonage.com\n * @Date: 2019-09-19 17:35:19\n * @Last Modified by: Alexander.Vangelov@vonage.com\n * @Last Modified time: 2020-05-03 21:31:44\n */\n\nimport { Injectable, ApplicationRef, Injector } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { Observable } from 'rxjs';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class MetaReferenceService {\n  dialogs: Array<any>;\n  constructor(\n    private appRef: ApplicationRef,\n    private injector: Injector,\n    private router: Router) {\n      this.dialogs = [];\n      this.router.events.subscribe((e) => {\n        if (this.dialogs.length) {\n          for (let d = (this.dialogs.length - 1); d >= 0; d--) {\n            this.dialogs[d].onComplete();\n          }\n        }\n      });\n    }\n\n  openDialog(refDialogFactory, metaResource, integrationCode, reference, resource, preview?: boolean, preferResourceType?, theme?: string) {\n    const references = !(reference instanceof Array) ? [reference] : reference.filter((r) => r.creatable !== false);\n    if (resource && resource.type) {\n      if (!references.find((f) => (f.name || f.resourceType) === (resource.resourceType || resource.type))) {\n        references.push({\n          name: resource.resourceType || resource.type,\n          resourceType: resource.resourceType || resource.type,\n          label: resource.label || resource.resourceType || resource.type\n        });\n      }\n    }\n\n    const modalObservable = new Observable(observer => {\n      const componentRef = refDialogFactory.create(this.injector);\n      this.appRef.attachView(componentRef.hostView);\n      const refDialog = componentRef.instance;\n      refDialog.integrationCode = integrationCode;\n      refDialog.reference = references;\n      refDialog.resource = resource;\n      refDialog.metaResource = metaResource;\n      refDialog.edit = !preview;\n      refDialog.preferResourceType = preferResourceType;\n      refDialog.theme = theme;\n\n      const domElem = (componentRef.hostView as any).rootNodes[0] as HTMLElement;\n      \n      const dialogIndex = this.dialogs.push(refDialog);\n\n      if (dialogIndex > 1) {\n        const modalPanel: HTMLElement = domElem.querySelector('.Vlt-modal__panel');\n        if (modalPanel) {\n          modalPanel.style.marginLeft = `${(dialogIndex * 5)}px`;\n          modalPanel.style.marginTop = `${(dialogIndex * 10)}px`;\n          modalPanel.style.marginBottom = `${((dialogIndex - 1) * 8)}px`;\n        }\n      }\n\n      document.body.appendChild(domElem);\n\n      refDialog.onComplete = (result) => {\n        if (result) {\n          /* eslint-disable no-underscore-dangle */\n          if (result._vgis) {\n            observer.next({\n              id: result._vgis.externalId || result._vgis.id,\n              label: result._vgis.label,\n              type: result._vgis.resourceType,\n              raw: result\n            });\n          } else {\n            console.log('onComplete non VGIS result', result);\n          }\n          /* eslint-enable no-underscore-dangle */\n        } else {\n          observer.next();\n        }\n        observer.complete();\n        this.appRef.detachView(componentRef.hostView);\n        componentRef.destroy();\n        this.dialogs.splice(dialogIndex - 1, 1);\n      };\n    });\n\n    return modalObservable;\n  }\n}\n"]}

package/esm2015/lib/services/metaResource/index.js

@@ -0,0 +1,141 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2019-09-19 17:35:19
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2020-08-10 22:35:31
+ */
+import { Injectable } from '@angular/core';
+import { MetaHttpClient } from './metaHttpClient';
+import * as i0 from "@angular/core";
+import * as i1 from "./metaHttpClient";
+const STORAGE_PARAMS_REGEXES = {
+    localStorage: /^localStorage\.(.*)/,
+    sessionStorage: /^sessionStorage\.(.*)/,
+};
+const INTEGRATION_URL_TEMPLATE = '/extensions/v2/accounts/${localStorage.vgis.accountId}/users/${localStorage.vgis.userId}/connectors/${integrationCode}';
+const RESOURCE_URL_TEMPLATE = INTEGRATION_URL_TEMPLATE + '${parentsPath}/${resourceType}';
+const NEW_RESOURCE_URL_TEMPLATE = INTEGRATION_URL_TEMPLATE + '${parentsPath}/resources/${resourceType}';
+export class IMetaParentConfig {
+}
+export class IMetaResourceConfig {
+}
+export class MetaResourceService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    setConfig(config) {
+        this.baseIntegrationUrl = INTEGRATION_URL_TEMPLATE.replace(/\${\s*([\w\.]+)\s*}/g, (m, value) => {
+            for (const storage of Object.keys(STORAGE_PARAMS_REGEXES)) {
+                const match = value.match(STORAGE_PARAMS_REGEXES[storage]);
+                if (match) {
+                    return window[storage].getItem(match[1]) || window[storage].getItem(`cti.${match[1]}`);
+                }
+            }
+            return config[value];
+        });
+        this.baseResourceUrl = RESOURCE_URL_TEMPLATE.replace(/\${\s*([\w\.]+)\s*}/g, (m, value) => {
+            for (const storage of Object.keys(STORAGE_PARAMS_REGEXES)) {
+                const match = value.match(STORAGE_PARAMS_REGEXES[storage]);
+                if (match) {
+                    return window[storage].getItem(match[1]) || window[storage].getItem(`cti.${match[1]}`);
+                }
+            }
+            if (value === 'parentsPath') {
+                let parentsPath = '';
+                if (config.parent) { // config.parent: { resourceType: '...', id: '...', parent: {...} }
+                    let rootParent = config.parent;
+                    while (rootParent) {
+                        parentsPath += `/${rootParent.resourceType || rootParent.type}/${rootParent.externalId || rootParent.id}`;
+                        rootParent = rootParent.parent;
+                    }
+                }
+                return parentsPath;
+            }
+            else {
+                return config[value];
+            }
+        });
+        this.newResourceUrl = NEW_RESOURCE_URL_TEMPLATE.replace(/\${\s*([\w\.]+)\s*}/g, (m, value) => {
+            for (const storage of Object.keys(STORAGE_PARAMS_REGEXES)) {
+                const match = value.match(STORAGE_PARAMS_REGEXES[storage]);
+                if (match) {
+                    return window[storage].getItem(match[1]);
+                }
+            }
+            if (value === 'parentsPath') {
+                let parentsPath = '';
+                if (config.parent) { // config.parent: { resourceType: '...', id: '...', parent: {...} }
+                    let rootParent = config.parent;
+                    while (rootParent) {
+                        parentsPath += `/${rootParent.resourceType || rootParent.type}/${rootParent.externalId || rootParent.id}`;
+                        rootParent = rootParent.parent;
+                    }
+                }
+                return parentsPath;
+            }
+            else {
+                return config[value];
+            }
+        });
+        this.id = config.externalId;
+    }
+    new(config) {
+        const s = new MetaResourceService(this.httpClient);
+        s.setConfig(config);
+        return s;
+    }
+    searchIntegration(query, scope) {
+        let searchUrl = `${this.baseIntegrationUrl}/search?q=${encodeURIComponent(query)}`;
+        if (scope) {
+            searchUrl += `&scope=${encodeURIComponent(scope)}`;
+        }
+        return this.httpClient.get(searchUrl);
+    }
+    getMetadata(layoutId, refresh) {
+        let url = `${this.baseResourceUrl.replace('/v2/', '/v3/')}/metadata`;
+        url += `?t=${new Date().getTime()}`;
+        if (refresh) {
+            url += '&refresh=true';
+        }
+        if (layoutId) {
+            url += `&layoutId=${layoutId}`;
+        }
+        return this.httpClient.get(url);
+    }
+    getDetails(externalId, extraParams) {
+        let params = 'referenceDetails=true';
+        if (extraParams) {
+            for (const p in extraParams) {
+                if (extraParams[p]) {
+                    params += `&${p}=${extraParams[p]}`;
+                }
+            }
+        }
+        return this.httpClient.get(`${this.baseResourceUrl}/${externalId}?${params}`);
+    }
+    getByPath(path) {
+        let fullPath = `${this.newResourceUrl}${path}`;
+        if (/^..\//.test(path)) {
+            fullPath = `${this.baseIntegrationUrl}${path.substring(2)}`;
+        }
+        return this.httpClient.get(fullPath);
+    }
+    save(payload) {
+        if (this.id) {
+            return this.httpClient.put(`${this.baseResourceUrl}/${this.id}`, payload);
+        }
+        else {
+            return this.httpClient.post(`${this.baseResourceUrl}`, payload);
+        }
+    }
+}
+MetaResourceService.ɵprov = i0.ɵɵdefineInjectable({ factory: function MetaResourceService_Factory() { return new MetaResourceService(i0.ɵɵinject(i1.MetaHttpClient)); }, token: MetaResourceService, providedIn: "root" });
+MetaResourceService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+MetaResourceService.ctorParameters = () => [
+    { type: MetaHttpClient }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../projects/meta-ui/src/lib/services/metaResource/index.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * @Author: Alexander.Vangelov@vonage.com \n * @Date: 2019-09-19 17:35:19 \n * @Last Modified by: Alexander.Vangelov@vonage.com\n * @Last Modified time: 2020-08-10 22:35:31\n */\n\nimport { Injectable } from '@angular/core';\n\nimport { MetaHttpClient } from './metaHttpClient';\n\nconst STORAGE_PARAMS_REGEXES = {\n  localStorage: /^localStorage\\.(.*)/,\n  sessionStorage: /^sessionStorage\\.(.*)/,\n};\n\nconst INTEGRATION_URL_TEMPLATE =\n  '/extensions/v2/accounts/${localStorage.vgis.accountId}/users/${localStorage.vgis.userId}/connectors/${integrationCode}';\nconst RESOURCE_URL_TEMPLATE = INTEGRATION_URL_TEMPLATE + '${parentsPath}/${resourceType}';\nconst NEW_RESOURCE_URL_TEMPLATE = INTEGRATION_URL_TEMPLATE + '${parentsPath}/resources/${resourceType}';\n\nexport class IMetaParentConfig {\n  resourceType: string;\n  externalId: string;\n  parent?: IMetaParentConfig;\n}\nexport class IMetaResourceConfig {\n  integrationCode: string;\n  resourceType: string;\n  externalId?: string;\n  parent?: IMetaParentConfig;\n  urlTemplate?: string;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class MetaResourceService {\n  baseIntegrationUrl: string;\n  baseResourceUrl: string;\n  newResourceUrl: string;\n  id: string;\n\n  constructor(private httpClient: MetaHttpClient) { }\n\n  setConfig(config: IMetaResourceConfig) {\n    this.baseIntegrationUrl = INTEGRATION_URL_TEMPLATE.replace(/\\${\\s*([\\w\\.]+)\\s*}/g, (m, value) => {\n      for (const storage of Object.keys(STORAGE_PARAMS_REGEXES)) {\n        const match = value.match(STORAGE_PARAMS_REGEXES[storage]);\n        if (match) {\n          return window[storage].getItem(match[1]) || window[storage].getItem(`cti.${match[1]}`);\n        }\n      }\n      return config[value];\n    });\n    this.baseResourceUrl = RESOURCE_URL_TEMPLATE.replace(/\\${\\s*([\\w\\.]+)\\s*}/g, (m, value) => {\n      for (const storage of Object.keys(STORAGE_PARAMS_REGEXES)) {\n        const match = value.match(STORAGE_PARAMS_REGEXES[storage]);\n        if (match) {\n          return window[storage].getItem(match[1]) || window[storage].getItem(`cti.${match[1]}`);\n        }\n      }\n      if (value === 'parentsPath') {\n        let parentsPath = '';\n        if (config.parent) { // config.parent: { resourceType: '...', id: '...', parent: {...} }\n          let rootParent: any = config.parent;\n          while (rootParent) {\n            parentsPath += `/${rootParent.resourceType || rootParent.type}/${rootParent.externalId || rootParent.id}`;\n            rootParent = rootParent.parent;\n          }\n        }\n        return parentsPath;\n      } else {\n        return config[value];\n      }\n    });\n    this.newResourceUrl = NEW_RESOURCE_URL_TEMPLATE.replace(/\\${\\s*([\\w\\.]+)\\s*}/g, (m, value) => {\n      for (const storage of Object.keys(STORAGE_PARAMS_REGEXES)) {\n        const match = value.match(STORAGE_PARAMS_REGEXES[storage]);\n        if (match) {\n          return window[storage].getItem(match[1]);\n        }\n      }\n      if (value === 'parentsPath') {\n        let parentsPath = '';\n        if (config.parent) { // config.parent: { resourceType: '...', id: '...', parent: {...} }\n          let rootParent: any = config.parent;\n          while (rootParent) {\n            parentsPath += `/${rootParent.resourceType || rootParent.type}/${rootParent.externalId || rootParent.id}`;\n            rootParent = rootParent.parent;\n          }\n        }\n        return parentsPath;\n      } else {\n        return config[value];\n      }\n    });\n    this.id = config.externalId;\n  }\n\n  new(config: IMetaResourceConfig) {\n    const s = new MetaResourceService(this.httpClient);\n    s.setConfig(config);\n    return s;\n  }\n\n  searchIntegration(query, scope?: string) {\n    let searchUrl = `${this.baseIntegrationUrl}/search?q=${encodeURIComponent(query)}`;\n    if (scope) {\n      searchUrl += `&scope=${encodeURIComponent(scope)}`;\n    }\n    return this.httpClient.get(searchUrl);\n  }\n\n  getMetadata(layoutId?, refresh?) {\n    let url = `${this.baseResourceUrl.replace('/v2/', '/v3/')}/metadata`;\n    url += `?t=${new Date().getTime()}`;\n    if (refresh) {\n      url += '&refresh=true';\n    }\n    if (layoutId) {\n      url += `&layoutId=${layoutId}`;\n    }\n    return this.httpClient.get(url);\n  }\n\n  getDetails(externalId, extraParams?) {\n    let params = 'referenceDetails=true';\n    if (extraParams) {\n      for (const p in extraParams) {\n        if (extraParams[p]) {\n          params += `&${p}=${extraParams[p]}`;\n        }\n      }\n    }\n    return this.httpClient.get(`${this.baseResourceUrl}/${externalId}?${params}`);\n  }\n\n  getByPath(path) { // TODO not universal!\n    let fullPath = `${this.newResourceUrl}${path}`;\n    if (/^..\\//.test(path)) {\n      fullPath = `${this.baseIntegrationUrl}${path.substring(2)}`;\n    }\n    return this.httpClient.get(fullPath);\n  }\n\n  save(payload) {\n    if (this.id) {\n      return this.httpClient.put(\n        `${this.baseResourceUrl}/${this.id}`,\n        payload\n      );\n    } else {\n      return this.httpClient.post(\n        `${this.baseResourceUrl}`,\n        payload\n      );\n    }\n  }\n}\n"]}

package/esm2015/lib/services/metaResource/metaHttpClient.js

@@ -0,0 +1,65 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2019-09-19 17:35:19
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2019-11-22 14:57:07
+ */
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class MetaHttpClient {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    delete(url, queryParams = {}) {
+        const options = this.prepareOptions(queryParams);
+        return this.httpClient.delete(`${this.constructUrl(url)}`, options);
+    }
+    get(url, queryParams = {}) {
+        const options = this.prepareOptions(queryParams);
+        return this.httpClient.get(`${this.constructUrl(url)}`, options);
+    }
+    post(url, body, queryParams = {}) {
+        const options = this.prepareOptions(queryParams);
+        return this.httpClient.post(`${this.constructUrl(url)}`, body, options);
+    }
+    put(url, body, queryParams = {}) {
+        const options = this.prepareOptions(queryParams);
+        return this.httpClient.put(`${this.constructUrl(url)}`, body, options);
+    }
+    patch(url, body, queryParams = {}) {
+        const options = this.prepareOptions(queryParams);
+        return this.httpClient.patch(`${this.constructUrl(url)}`, body, options);
+    }
+    constructUrl(path) {
+        return /^http/.test(path) ? path : `${path}`;
+    }
+    prepareOptions(queryParams) {
+        Object.keys(queryParams).forEach(key => {
+            if (queryParams[key] == null || queryParams[key] === '') {
+                delete queryParams[key];
+            }
+        });
+        const params = new HttpParams({
+            fromObject: queryParams
+        });
+        const options = {
+            headers: new HttpHeaders({
+                Accept: 'application/json' // eslint-disable-line @typescript-eslint/naming-convention
+            }),
+            params
+        };
+        return options;
+    }
+}
+MetaHttpClient.ɵprov = i0.ɵɵdefineInjectable({ factory: function MetaHttpClient_Factory() { return new MetaHttpClient(i0.ɵɵinject(i1.HttpClient)); }, token: MetaHttpClient, providedIn: "root" });
+MetaHttpClient.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+MetaHttpClient.ctorParameters = () => [
+    { type: HttpClient }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/metaTracker/index.js

@@ -0,0 +1,30 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2019-09-19 17:35:19
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2020-03-23 17:08:23
+ */
+import { Injectable, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MetaTrackerService {
+    constructor() {
+        this.events = new EventEmitter();
+    }
+    emit(event) {
+        if (!event.integration) {
+            event.integration = this.integrationCode || 'N/A';
+        }
+        if (!event.resource) {
+            event.resource = this.resourceType || 'N/A';
+        }
+        this.events.emit(event);
+    }
+}
+MetaTrackerService.ɵprov = i0.ɵɵdefineInjectable({ factory: function MetaTrackerService_Factory() { return new MetaTrackerService(); }, token: MetaTrackerService, providedIn: "root" });
+MetaTrackerService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+MetaTrackerService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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