@vgip/meta-ui 2.1.1 → 2.1.3

package/src/lib/common/utils/indexedDbStore/index.ts

@@ -0,0 +1,244 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2020-02-10 18:47:45
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2020-02-28 13:29:23
+ */
+
+export interface IStoreRecord {
+  id?: string | number;
+}
+
+export interface IStore {
+  initCollection(collectionName: string, callback?: (err, result?) => void): any;
+  findById(collectionName, id: number | string, callback?: (err, result?) => void): any;
+  save(collectionName: string, record: any, callback?: (err, result?) => void): any;
+  find(collectionName: string, conditions: any, options: any, callback: (err, result?) => void);
+  findOne(collectionName: string, conditions: any, options: any, callback?: (err, result?) => void);
+}
+
+export class IndexedDbStore implements IStore {
+  indxDb: IDBFactory;
+  db: IDBDatabase;
+  dbName: string;
+
+  constructor(dbName: string = 'vgip') {
+    this.dbName = dbName;
+    this.indxDb = window.indexedDB || (window as any).mozIndexedDB || (window as any).webkitIndexedDB || (window as any).msIndexedDB;
+  }
+
+  _getDb(callback: (err, result?) => void) {
+    const self = this;
+    if (this.db) {
+      return callback(null, this.db);
+    }
+    const req = this.indxDb.open(this.dbName, 3);
+    req.onupgradeneeded = (ev: any) => {
+      self.db = ev.target.result;
+      if (!self.db.objectStoreNames.contains('Draft')) {
+        this.createDraftStore();
+      }
+    };
+    if (callback) {
+      req.onsuccess = (ev: any) => {
+        self.db = ev.target.result;
+        callback(null, self.db);
+      };
+    }
+    req.onerror = (ev: any) => {
+      if (callback) {
+        callback(ev.error);
+      }
+    };
+  }
+
+  initCollection(collectionName: string, callback: (err, result?) => void) {
+    const self = this;
+    this._getDb((err) => { // eslint-disable-line no-underscore-dangle
+      if (typeof(callback) === 'function') {
+        if (err) {
+          return callback(err);
+        } else if (!self.db.objectStoreNames.contains(collectionName)) {
+          return callback(new Error(`IDBDatabase store ${collectionName} does not exist!`));
+        } else {
+          callback(null, self.db);
+        }
+      }
+    });
+  }
+
+  reset(callback: (err, result?) => void) {
+    this._getDb((err) => { // eslint-disable-line no-underscore-dangle
+      if (err) {
+        return callback(err);
+      }
+      this.db.close();
+      this.indxDb.deleteDatabase(this.dbName);
+      delete this.db;
+      this._getDb(callback); // eslint-disable-line no-underscore-dangle
+    });
+  }
+
+  findById(collectionName: string, id: number | string, callback: (err, result?) => void): any {
+    const tx = this.db.transaction([collectionName]);
+    const store = tx.objectStore(collectionName);
+    const request = store.get(parseInt(`${id}`, 10));
+    if (callback) {
+      request.onerror = () => {
+        callback(request.error);
+      };
+    }
+    request.onsuccess = () => {
+      if (!request.result) {
+        callback({ message: 'Not Found' });
+      } else if (callback) {
+        callback(null, request.result);
+      }
+    };
+  }
+
+  destroyById(collectionName: string, id: number | string, callback: (err, result?) => void): any {
+    const tx = this.db.transaction([collectionName], 'readwrite');
+    const store = tx.objectStore(collectionName);
+    const request = store.delete(parseInt(`${id}`, 10));
+    if (callback) {
+      request.onerror = () => {
+        callback(request.error);
+      };
+    }
+    request.onsuccess = () => {
+      if (callback) {
+        callback(null, request.result);
+      }
+    };
+  }
+
+  findOne(collectionName: string, conditions: any, options: any, callback?: (err, result?) => void): any {
+    const tx = this.db.transaction([collectionName]);
+    const store = tx.objectStore(collectionName);
+    const conditionsKeys = Object.keys(conditions);
+    let idx: IDBIndex;
+    let req: IDBRequest;
+    if (conditionsKeys.length > 1) {
+      const vals = [];
+      conditionsKeys.forEach((key) => vals.push(conditions[key]));
+      idx = store.index(`${conditionsKeys.join('')}Index`);
+      req = idx.get(vals);
+    } else {
+      idx = store.index(`${conditionsKeys[0]}Index`);
+      req = idx.get(conditions[conditionsKeys[0]]);
+    }
+    if (callback) {
+      req.onerror = () => {
+        callback(req.error);
+      };
+    }
+    req.onsuccess = (ev: any) => {
+      if (!ev.target.result) {
+        callback({ message: 'Not Found' });
+      } else if (callback) {
+        callback(null, ev.target.result);
+      }
+    };
+  }
+
+  find(collectionName: string, conditions: any, options: any, callback?: (err, result?) => void): Array<IStoreRecord> | any {
+    const tx = this.db.transaction([collectionName]);
+    const store = tx.objectStore(collectionName);
+    const conditionsKeys = Object.keys(conditions);
+    let idx: IDBIndex;
+    let req: IDBRequest;
+    if (conditionsKeys.length > 1) {
+      const vals = [];
+      conditionsKeys.forEach((key) => vals.push(conditions[key]));
+      idx = store.index(`${conditionsKeys.join('')}Index`);
+      req = idx.openCursor(vals);
+    } else {
+      idx = store.index(`${conditionsKeys[0]}Index`);
+      req = idx.openCursor(conditions[conditionsKeys[0]]);
+    }
+    req.onerror = () => {
+      if (callback) {
+        callback(req.error);
+      }
+    };
+    const items = [];
+    req.onsuccess = (ev: any) => {
+      const cursor = ev.target.result;
+      if (cursor) {
+        items.push(cursor.value);
+        cursor.continue();
+      } else if (callback) {
+        callback(null, items);
+      }
+    };
+  }
+
+  save(collectionName: string, model: any, callback?: (err, result?) => void) {
+    const record = model; // model.toJson(true, false);
+    const createNew = () => {
+      const txN = this.db.transaction([collectionName], 'readwrite');
+      const request = txN.objectStore(collectionName).add(record);
+      if (callback) {
+        request.onerror = () => callback(request.error);
+      }
+      request.onsuccess = () => {
+        record.id = request.result;
+        if (callback) {
+          callback(null, record);
+        }
+      };
+    };
+
+    const updateOldById = (id) => {
+      const txO = this.db.transaction([collectionName], 'readwrite');
+      const storeW = txO.objectStore(collectionName);
+      const getRequest = storeW.get(id);
+      if (callback) {
+        getRequest.onerror = () => callback(getRequest.error);
+      }
+      getRequest.onsuccess = () => {
+        const existing = getRequest.result;
+        if (!existing) {
+          callback({ message: 'Not Found' });
+        } else {
+          for (const p of Object.keys(record)) {
+            existing[p] = record[p];
+          }
+          const updateRequest = storeW.put(existing);
+          updateRequest.onerror = () => callback(updateRequest.error);
+          updateRequest.onsuccess = () => {
+            if (typeof (callback) === 'function') {
+              callback(null, existing);
+            }
+          };
+        }
+      };
+    };
+
+    if (record.id) {
+      updateOldById(record.id);
+    } else if (record.integration && record.resource) {
+      this.findOne(collectionName, {
+        context: record.context || '',
+        integration: record.integration || '',
+        resource: record.resource || ''
+      }, null, (err, existing) => {
+        if (!existing) {
+          createNew();
+        } else {
+          updateOldById(existing.id);
+        }
+      });
+    } else {
+      createNew();
+    }
+  }
+
+  private createDraftStore() {
+    const objectStore = this.db.createObjectStore('Draft', { keyPath: 'id', autoIncrement: true });
+    objectStore.createIndex('contextIndex', 'context', { unique: false });
+    objectStore.createIndex('contextintegrationIndex', ['context', 'integration'], { unique: false });
+    objectStore.createIndex('contextintegrationresourceIndex', ['context', 'integration', 'resource'], { unique: true });
+  }
+}

package/src/lib/common/utils/indexedDbStore/indexedDbStore.spec.ts

@@ -0,0 +1,149 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2020-02-10 18:47:45
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2020-02-10 21:07:14
+ */
+
+import { IndexedDbStore } from './index';
+
+describe('IndexedDbStore', () => {
+  let store: IndexedDbStore;
+  const collectionName = 'Draft';
+  const mockModel = (record) => record;
+
+  beforeAll((done) => {
+    store = new IndexedDbStore('items');
+    store.reset(() => {
+      done();
+    });
+  });
+
+  it('init', (done) => {
+    store.reset((e1) => {
+      expect(e1).toBeNull();
+      store.initCollection(collectionName, (err) => {
+        expect(err).toBeNull();
+        done();
+      });
+    });
+  });
+
+  it('findById', (done) => {
+    store.findById(collectionName, 10000, (err) => {
+      expect(err.message).toEqual('Not Found');
+      done();
+    });
+  });
+
+  it('save (create)', (done) => {
+    store.save(collectionName, mockModel({}), (err, record) => {
+      expect(record.id).toBeDefined();
+      done();
+    });
+  });
+
+  it('create - increment id', (done) => {
+    store.save(collectionName, mockModel({}), (e1, record1) => {
+      expect(record1.id).toBeDefined();
+      store.save(collectionName, mockModel({}), (e2, record2) => {
+        expect(record2.id).toEqual(record1.id + 1);
+        store.save(collectionName, mockModel({}), (e3, record3) => {
+          expect(record3.id).toEqual(record2.id + 1);
+          done();
+        });
+      });
+    });
+  });
+
+  it('create - search', (done) => {
+    store.save('Draft', mockModel({ context: 'ccc', integration: 'mocks1', resource: 'Demo1' }), (e1, r1) => {
+      expect(r1.id).toBeDefined();
+      store.save('Draft', mockModel({ context: 'ddd', integration: 'mocks2', resource: 'Demo2' }), (e2, r2) => {
+        expect(r2.id).toEqual(r1.id + 1);
+        store.save('Draft', mockModel({ context: 'ddd', integration: 'mocks3', resource: 'Demo3' }), (e3, record3) => {
+          expect(record3.id).toEqual(r2.id + 1);
+          store.find('Draft', { context: 'ddd' }, {}, (err, records) => {
+            expect(records.length).toEqual(2);
+            done();
+          });
+        });
+      });
+    });
+  });
+
+  it('save (update)', (done) => {
+    store.save(collectionName, mockModel({ context: '', integration: 'mocks', resource: 'Demo', data: 'aaa' }), (e1, r1) => {
+      r1.data = 'bbb';
+      expect(r1.id).toBeDefined();
+      store.save(collectionName, mockModel({ id: r1.id, data: 'bbb' }), (err, updatedRecord) => {
+        expect(updatedRecord.id).toEqual(r1.id);
+        expect(updatedRecord.data).toEqual('bbb');
+        done();
+      });
+    });
+  });
+
+  it('find', (done) => {
+    store.save('Draft', mockModel({ context: 'zzz', integration: 'mocks', resource: 'Demo1' }), (e1) => {
+      expect(e1).toBeNull();
+      store.save('Draft', mockModel({ context: 'zzz', integration: 'mocks', resource: 'Demo2' }), () => {
+        store.find('Draft', { context: 'zzz' }, null, (err, records) => {
+          expect(err).toBeNull();
+          expect(records).toBeDefined();
+          expect(records.length).toEqual(2);
+          if (records.length) {
+            expect(records[0].resource).toEqual('Demo1');
+            expect(records[1].resource).toEqual('Demo2');
+          }
+          done();
+        });
+      });
+    });
+  });
+
+  it('findOne', (done) => {
+    store.save('Draft', mockModel({ context: 'eee', integration: 'mocks', resource: 'Demo1' }), () => {
+      store.save('Draft', mockModel({ context: 'eee', integration: 'mocks', resource: 'Demo2' }), () => {
+        store.findOne('Draft', { context: 'eee' }, null, (err, record) => {
+          expect(err).toBeNull();
+          expect(record.id).toBeDefined();
+          expect(record.integration).toEqual('mocks');
+          expect(record.resource).toEqual('Demo1');
+          done();
+        });
+      });
+    });
+  });
+
+  it('findOne (multi index)', (done) => {
+    store.save('Draft', mockModel({ context: 'aaa', integration: 'mocks', resource: 'Demo', data: '{}' }), (err1) => {
+      expect(err1).toBeNull();
+      store.save('Draft', mockModel({ context: 'bbb', integration: 'mocks', resource: 'Demo', data: '{}' }), () => {
+        store.findOne('Draft', { context: 'bbb', integration: 'mocks', resource: 'Demo' }, null, (err, record) => {
+          expect(err).toBeNull();
+          expect(record).toBeDefined();
+          expect(record.context).toEqual('bbb');
+          expect(record.integration).toEqual('mocks');
+          expect(record.resource).toEqual('Demo');
+          expect(record.data).toEqual('{}');
+          done();
+        });
+      });
+    });
+  });
+
+  it('destroy', (done) => {
+    store.save(collectionName, mockModel({ context: 'yyy', integration: 'mocks', resource: 'Demo', data: '{}' }), (err1, r1) => {
+      expect(err1).toBeNull();
+      expect(r1.id).toBeDefined();
+      store.destroyById(collectionName, r1.id, (err, record) => {
+        expect(record).toBeUndefined();
+        store.findById(collectionName, r1.id, (err2) => {
+          expect(err2.message).toEqual('Not Found');
+          done();
+        });
+      });
+    });
+  });
+});

package/src/lib/common/utils/relativeTimeBuilder.ts

@@ -0,0 +1,49 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com 
+ * @Date: 2019-09-19 17:35:19 
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2020-02-18 15:41:17
+ */
+
+const wordToMilliseconds = {
+  now: 0,
+  seconds: 1000,
+  minutes: 1000 * 60,
+  hours: 1000 * 60 * 60,
+  days: 1000 * 60 * 60 * 24
+};
+
+const protoTime = (text) => { // protocol is: 30.minutes, -4.hours, 3.days, etc...
+  const protoMatch = (text || '').match(/^(-?)((\d+).)?(\S+)$/);
+  if (protoMatch) {
+    const negative = protoMatch[1] === '-';
+    const units = parseInt(protoMatch[3], 10) * (wordToMilliseconds[protoMatch[4]] || 0);
+    if (negative) {
+      return -units;
+    } else {
+      return units;
+    }
+  }
+};
+
+export const relativeTimeBuilder = (type: 'date' | 'datetime' | 'datetime-local' | 'time', value: string, step = 0, base?: number) => {
+  let timestamp = base || new Date().getTime();
+  const offset = protoTime(value);
+  if (offset) {
+    timestamp = timestamp + offset;
+  }
+  if (step) {
+    if (type === 'date') { // step is days
+      const mod = timestamp % (step * 1000 * 60 * 60 * 24);
+      if (mod) {
+        timestamp = timestamp - mod + (step * 1000 * 60 * 60 * 24);
+      }
+    } else {  // step is seconds
+      const mod = timestamp % (step * 1000);
+      if (mod) {
+        timestamp = timestamp - mod + (step * 1000);
+      }
+    }
+  }
+  return timestamp;
+};

package/src/lib/common/utils/resourceCardLabel.ts

@@ -0,0 +1,25 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2023-02-08 12:41:56
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2023-02-08 14:04:46
+ */
+const pad2Digit = (t) => t < 10 ? '0' + t : t;
+
+export const resourceCardLabel = (r: any) => { // TODO make pipe to ask integration worker for this in abstract
+  // eslint-disable-next-line no-underscore-dangle
+  if (r._vgis && r._vgis.connector === 'CLIO' && r._vgis.resourceType === 'PhoneCommunicationTimer') {
+    const duration = r.quantity || 0; // in seconds
+    let durationText = '00:00';
+    if (duration > 0) {
+      const hours = Math.floor(duration / 3600);
+      const minutes = Math.floor((duration % 3600) / 60);
+      const seconds = Math.round(duration % 60);
+      const checkHours = hours ? pad2Digit(hours) + ':' : '';
+
+      durationText = checkHours + pad2Digit(minutes) + ':' + pad2Digit(seconds);
+    }
+    return `⏱ ${ durationText } | $${ (Math.round(r.price) * 100 ) / 100} | ${ r.non_billable ? 'Non-billable' : 'Billable'  }`;
+  }
+  return r.Subject || r.subject || r.summary || r.title || r.CaseNumber || r.comment || r.body || r.name || r.topic || r.content || '...';
+};

package/src/lib/common/utils/smartProp.spec.ts

@@ -0,0 +1,24 @@
+import { extractValueBySmartProp } from './smartProp';
+
+describe('SmartProp', () => {
+  it('extract undefined', () => {
+    const rootObj = { whoId: { id: 1, type: 'Lead', label: 'Test' } };
+    expect(extractValueBySmartProp(rootObj, 'nonExisting')).toBeUndefined();
+    expect(extractValueBySmartProp(rootObj, 'whoId.nonExisting')).toBeUndefined();
+  });
+
+  it('extract root property', () => {
+    const rootObj = { a: 1 };
+    expect(extractValueBySmartProp(rootObj, 'a')).toEqual(1);
+  });
+
+  it('extract nested property', () => {
+    const rootObj = { whoId: { id: 1, type: 'Lead', label: 'Test' } };
+    expect(extractValueBySmartProp(rootObj, 'whoId.type')).toEqual('Lead');
+  });
+
+  it('extract deep nested property', () => {
+    const rootObj = { children: { whoId: { id: 1, type: 'Lead', label: 'Test' } } };
+    expect(extractValueBySmartProp(rootObj, 'children.whoId.type')).toEqual('Lead');
+  });
+});

package/src/lib/common/utils/smartProp.ts

@@ -0,0 +1,28 @@
+export const extractValueBySmartProp = (rootObj, prop) => {
+  //  { WhoId: { id: 1, type: 'Contact' } } // "WhoId.type" -> 'Contact'
+  if (rootObj.hasOwnProperty(prop)) {
+    return rootObj[prop];
+  } else {
+    const parts = prop.split('.');
+    if (parts.length > 1) {
+      if (rootObj.hasOwnProperty(parts[0])) {
+        if (typeof (rootObj[parts[0]]) === 'object' && rootObj[parts[0]][parts[1]]) {
+          return extractValueBySmartProp(rootObj[parts[0]], prop.substring(parts[0].length + 1));
+        }
+      }
+    }
+  }
+};
+
+export const extractBooleanValueBySmartProp = (rootValue, visibleObj) => {
+  if (rootValue) {
+    if(typeof(rootValue) === 'boolean') {
+      return visibleObj !== rootValue;
+    }else{
+      return rootValue !== '' ? visibleObj !== true : visibleObj !== false;
+    }
+  } else {
+    // rootValue is undefined
+    return visibleObj !== false;
+  }
+};

package/src/lib/common/utils/templateBuilder.ts

@@ -0,0 +1,99 @@
+export const templateBuilder = (metaContext, pattern) => {
+  const context = (metaContext || {}).context;
+  if (!context) {
+    if (!pattern || typeof(pattern) !== 'string') {
+      return;
+    } else {
+      return (pattern || '').replace(/\${\s*([\w.]+)\s*}/g, 'N/A');
+    }
+  }
+
+  const padTime = (t) => t < 10 ? '0' + t : t;
+
+  const patternBuilder = (pattern || '').replace(/\${\s*([\w.]+)\s*}/g, (match, value) => {
+    switch (value) {
+      case 'direction': {
+        return (context[value] || '').toUpperCase() === 'INBOUND' ?  'Inbound' : 'Outbound';
+      }
+      case 'name': {
+        return context.contact ? context.contact.name : (context.callerId || 'Unknown');
+      }
+      case 'contact': { // (FE-BE contract violation)
+        return context.contact ? context.contact.name : (context.callerId || 'Unknown');
+      }
+      case 'type': {
+        return context.type ? context.type : '';
+      }
+      case 'phoneNumber': {
+        return context[value];
+      }
+      case 'directionArrow': {
+        return (context.direction || '').toUpperCase() === 'INBOUND' ? '⬇' : '⬆';
+      }
+      case 'timestamp': {
+        try {
+          const callTime = new Date(context.answerTime || context.startTime || Date.now());
+          const date = callTime.toDateString();
+          const time = callTime.toLocaleTimeString();
+          return date + ', ' + time;
+        } catch (e) {
+          console.error('context without startTime', e);
+        }
+        return '';
+      }
+      case 'duration': {
+        try {
+          if (typeof (context[value]) === 'number' && context.endTime) {
+            return '(' + (context[value]).toFixed() + 'ms)';
+          }
+        } catch (e) {
+          console.error('context without duration', e);
+        }
+        return '(0ms)';
+      }
+      case 'durationSec': {
+        try {
+          if (typeof (context.duration) === 'number' && context.endTime) {
+            return '(' + (context.duration / 1000).toFixed() + 's)';
+          }
+        } catch (e) {
+          console.error('call without duration', e);
+        }
+        return '(0s)';
+      }
+      case 'durationTime': {
+        try {
+          if (typeof (context.duration) === 'number' && context.endTime) {
+            const duration = context.duration / 1000; // convert it to seconds
+            if (duration < 0) {
+              return '00:00';
+            }
+
+            const hours = Math.floor(duration / 3600);
+            const minutes = Math.floor((duration % 3600) / 60);
+            const seconds = Math.floor(duration % 60);
+
+            const checkHours = hours ? padTime(hours) + ':' : '';
+            return checkHours + padTime(minutes) + ':' + padTime(seconds);
+          }
+        } catch (e) {
+          console.error('context without duration', e);
+        }
+        return '00:00';
+      }
+      default: {
+        const nestedTagMatch = value.match(/(\S+)\.(\S+)/);
+        if (nestedTagMatch) {
+          if (typeof(context[nestedTagMatch[1]]) === 'object') {
+            return context[nestedTagMatch[1]][nestedTagMatch[2]] || '';
+          } else {
+            return '';
+          }
+        } else {
+          return context[value] || '';
+        }
+      }
+    }
+  });
+  return /^\s+$/.test(patternBuilder) ? '' : patternBuilder;
+};