@vgip/meta-ui 1.1.6 → 1.2.2

package/esm2020/lib/services/metaResource/metaHttpClient.mjs

@@ -0,0 +1,64 @@
+/*
+ * @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 { 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.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaHttpClient, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+MetaHttpClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaHttpClient, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaHttpClient, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/metaTracker/index.mjs

@@ -0,0 +1,31 @@
+/*
+ * @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.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MetaTrackerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaTrackerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: MetaTrackerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/resourceDrafts/index.mjs

@@ -0,0 +1,68 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2020-02-10 17:35:19
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2020-02-13 06:17:24
+ */
+import { Injectable } from '@angular/core';
+import { IndexedDbStore } from '../../common/utils/indexedDbStore';
+import * as i0 from "@angular/core";
+import * as i1 from "../metaContext";
+const COLELCTION = 'Draft';
+export class ResourceDraftsService {
+    constructor(context) {
+        this.context = context;
+        this.store = new IndexedDbStore('vgip');
+    }
+    init(cb) {
+        if (!this.db) {
+            this.store.initCollection(COLELCTION, null, (err, db) => {
+                this.db = db;
+                cb(err, this.db);
+            });
+        }
+        else {
+            cb(null, this.db);
+        }
+    }
+    list(integrationCode, resourceType, cb) {
+        console.log('list drafts', this.context.uid, integrationCode, resourceType);
+    }
+    save(integrationCode, resourceType, draft, cb) {
+        const now = new Date().getTime();
+        this.store.save(COLELCTION, {
+            context: this.context.uid || '',
+            integration: integrationCode || '',
+            resource: resourceType || '',
+            timestamp: now,
+            data: draft
+        }, cb);
+    }
+    findOne(integrationCode, resourceType, cb) {
+        this.store.findOne(COLELCTION, {
+            context: this.context.uid || '',
+            integration: integrationCode || '',
+            resource: resourceType || ''
+        }, null, cb);
+    }
+    find(params, cb) {
+        this.store.find(COLELCTION, params, null, cb);
+    }
+    findById(draftId, cb) {
+        this.store.findById(COLELCTION, draftId, cb);
+    }
+    destroyDraft(draft, cb) {
+        if (draft && draft.id) {
+            this.store.destroyById(COLELCTION, draft.id, cb);
+        }
+    }
+}
+ResourceDraftsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: ResourceDraftsService, deps: [{ token: i1.MetaContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+ResourceDraftsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: ResourceDraftsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: ResourceDraftsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MetaContextService }]; } });
+//# sourceMappingURL=data:application/json;base64,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