@tuki-io/tuki-widgets 0.0.26 → 0.0.28

package/projects/tuki/widgets/user-manage/src/services/dns.service.ts

@@ -0,0 +1,116 @@
+import { Injectable } from '@angular/core';
+import { API } from '../app.constants';
+import { APIService } from './api.service';
+import { map } from 'rxjs/operators';
+import { Observable } from 'rxjs';
+import { Big } from 'big.js';
+import { AvailablePhoneNumberRangeInterface, DnRangeType } from '../classes/line';
+// import * as Big from 'big.js';
+
+
+@Injectable()
+export class DnsService {
+  availableNumbers = {};
+  availableDidPatternsMappedToDn!: any;
+  constructor(
+    private apiService: APIService
+  ) {
+
+  }
+  public getNumberRange(siteId: string, routePartition: string, withdids?: boolean, from?: string, pageSize?: number): any {
+    // @ts-ignore
+    if (this.availableNumbers[routePartition] && this.availableNumbers[routePartition].length) {
+      return new Observable<any>(observer => {
+        // @ts-ignore
+        observer.next(this.availableNumbers[routePartition]);
+      });
+    }
+
+    this.availableDidPatternsMappedToDn = {};
+    pageSize = pageSize ? pageSize : 20;
+    const params = {dntype: DnRangeType.extension, routepartition: routePartition, size: pageSize, page: 0};
+    if (withdids) {
+      // @ts-ignore
+      params['withdids'] = 'true';
+    }
+    if (from) {
+      // @ts-ignore
+      params['from'] = from;
+    }
+    // @ts-ignore
+    this.availableNumbers[routePartition] = this.availableNumbers[routePartition] || [];
+
+    return this.apiService.fetch(API.AVAILABLE_DN_IN_RANGES.replace(':siteId', siteId), params)
+      .pipe(map((res: any) => {
+          res.availableNumberList.forEach((availableNumber: AvailablePhoneNumberRangeInterface) => {
+            this.setAvailableDidMappedToDn(availableNumber);
+            // @ts-ignore
+            this.availableNumbers[routePartition] = [...this.availableNumbers[routePartition], ...this.getUnwrapNumberRange(availableNumber)];
+          });
+        })
+      )
+      // .pipe(this.handleError(true, false));
+  }
+
+  public setAvailableDidMappedToDn(availableNumber: any): void {
+    if (availableNumber.unUsedNumbersWithDids && availableNumber.unUsedNumbersWithDids.length) {
+
+      availableNumber.unUsedNumbersWithDids.forEach((numberWithDids: any) => {
+        const dn = numberWithDids['unUsedNumber'];
+        this.availableDidPatternsMappedToDn[dn] = [{}];
+        if (numberWithDids['translationPatternList'] && numberWithDids['translationPatternList'].length > 0) {
+          this.availableDidPatternsMappedToDn[dn] = numberWithDids['translationPatternList'];
+          this.availableDidPatternsMappedToDn[dn][0]['mappedDids'] = [{}];
+          if (numberWithDids['mappedDids'] && numberWithDids['mappedDids'].length > 0) {
+            this.availableDidPatternsMappedToDn[dn][0]['mappedDids'] = numberWithDids['mappedDids'];
+          }
+        }
+        this.availableDidPatternsMappedToDn[dn][0]['vm'] = numberWithDids['vm'];
+      });
+    }
+  }
+
+  public getUnwrapNumberRange(availableNumber: any): any {
+    const unwrapNumberRangeArray = this.unwrapNumberRange(availableNumber.phoneNumberRange.from, availableNumber.phoneNumberRange.to);
+    if (unwrapNumberRangeArray?.length) {
+      let unwrapNumberRange = unwrapNumberRangeArray.map((unwrappedNumber: string) => {
+          const dn = availableNumber.phoneNumberRange.prefix + unwrappedNumber;
+          let str = dn;
+          if (this.availableDidPatternsMappedToDn[dn] && this.availableDidPatternsMappedToDn[dn].length > 0) {
+            if (this.availableDidPatternsMappedToDn[dn][0]['mappedDids'] && this.availableDidPatternsMappedToDn[dn][0]['mappedDids'].length > 0) {
+              str += '        DID:  ' + (this.availableDidPatternsMappedToDn[dn][0]['mappedDids'].length > 1 ? 'multiple' :
+                this.availableDidPatternsMappedToDn[dn][0]['mappedDids'][0]);
+            }
+            if (this.availableDidPatternsMappedToDn[dn][0]['vm']) {
+              str += '        In Use - VM';
+            }
+          }
+          return str;
+        });
+      unwrapNumberRange = unwrapNumberRange.filter((unwrappedNumber: string) => !availableNumber.usedNumbers.includes(unwrappedNumber));
+      return unwrapNumberRange;
+    } else {
+      return [];
+    }
+
+  }
+
+  public unwrapNumberRange(start: string, end: string): string[] {
+    const regExp = /(^0+)/;
+    let leadingZeros = '';
+    const matches = start.match(regExp);
+    if (matches) {
+      leadingZeros = matches[1];
+    }
+    const startNumeric = new Big(start);
+    const endNumeric = new Big(end);
+    // @ts-ignore
+    return Array.from({length: (endNumeric.minus(startNumeric).plus(new Big(1)).toFixed(0))}, (v, k) => {
+      const number = String(startNumeric.plus(new Big(k)).toFixed(0));
+      if ((leadingZeros + number).length > start.length) {
+        leadingZeros = leadingZeros.substr(1);
+      }
+      return leadingZeros + number;
+    });
+  }
+}

package/projects/tuki/widgets/user-manage/src/services/line.service.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+
+@Injectable()
+export class LineService {
+  public generateLineAssociationFromLine(lineAssociation?: any) {
+   return {
+     directoryNumber: lineAssociation ? this.generateLineDirectory(lineAssociation) : null,
+     didPattern: lineAssociation ? this.generateDidPatternForLineAssociation(lineAssociation) : null,
+     mappedDids: lineAssociation ? '' : 'null',
+     index: lineAssociation ? lineAssociation.index : null,
+     position: lineAssociation ? lineAssociation.position : null,
+     textLabel: lineAssociation ? lineAssociation.textLabel : null,
+     // displayLabel: lineAssociation ? lineAssociation.displayLabel  : 'null',
+     alertingName: lineAssociation ? lineAssociation.alertingName : null,
+     callerNumber: lineAssociation ? '' : 'null'
+   }
+  }
+
+  generateLineDirectory(lineAssociation?: any): any {
+    return {
+      directoryNumber: lineAssociation.directoryNumber.directoryNumber,
+      routePartitionName: lineAssociation.directoryNumber.routePartitionName,
+    }
+  }
+
+  generateDidPatternForLineAssociation(lineAssociation?: any): any {
+    return {
+      calledPartyTransformationMask: lineAssociation.directoryNumber && lineAssociation.directoryNumber.directoryNumber
+    }
+  }
+}

package/projects/tuki/widgets/user-manage/src/services/notification.service.ts

@@ -0,0 +1,68 @@
+import { Injectable } from '@angular/core';
+import { Notification } from '../classes/notification';
+import { Subject } from 'rxjs';
+const SUCCESS_TIME = 5000;
+const INACTIVE_SESSION_MESSAGE = 'Your session was lost due to inactivity. Please login again';
+const INACTIVE_SESSION = 'SESSION_INACTIVE';
+
+@Injectable()
+export class NotificationService {
+
+  public listChange = new Subject();
+
+  private max = 0;
+  private list: Notification[] = [];
+
+  constructor(
+  ) {
+  }
+
+  error(message: string, ttl?: number): void {
+    this.notify('error', message, ttl);
+  }
+
+  success(message: string, ttl?: number): void {
+    this.notify('success', message, (!ttl) ? SUCCESS_TIME : ttl);
+  }
+
+  warning(message: string, ttl?: number): void {
+    this.notify('warning', message, ttl);
+  }
+
+  info(message: string, ttl?: number): void {
+    this.notify('info', message, ttl);
+  }
+  private notify(type: string, message: string, ttl?: number): void {
+    const found = this.list.find((n: Notification) => n.message === message);
+    if (found) {
+      this.remove(found);
+    }
+    const notification = new Notification({
+      id: ++this.max,
+      type, message, ttl
+    });
+    if (notification.ttl > 0) {
+      notification.timerId = setTimeout(() => this.remove(notification, true), notification.ttl);
+    }
+    this.list.push(notification);
+    this.listChange.next(this.list);
+  }
+
+  remove(notification: Notification, auto?: boolean): void {
+    if (!auto && notification.timerId) {
+      // clear timeout in case of manual remove
+      clearInterval(notification.timerId);
+    }
+    this.list = this.list.filter(n => n.id !== notification.id);
+    this.listChange.next(this.list);
+  }
+
+  private removeInactiveSessionError(): void {
+    if (!this.list || !this.list.length) {
+      return;
+    }
+    this.list = this.list.filter(n => n.message !== INACTIVE_SESSION_MESSAGE && n.message !== INACTIVE_SESSION);
+    this.listChange.next(this.list);
+  }
+
+}

package/projects/tuki/widgets/user-manage/src/services/removeKynFromIBM.service.ts

@@ -0,0 +1,25 @@
+import { Injectable } from '@angular/core';
+import { CUCMS_TO_IGNORE, CUCS_TO_IGNORE } from '../app.constants';
+
+@Injectable()
+export class RemoveKynFromIBMService {
+  constructor() {
+  }
+
+
+  removeCUCMS(date: any, customerId: number) {
+    if (customerId === 8) {
+      return date.filter((val: any) => !CUCMS_TO_IGNORE.includes(Math.round(val.cucmId)));
+    }
+    return date;
+  }
+
+  removeCUCS(date: any, customerId: number) {
+    if (customerId === 8) {
+      return date.filter((val: any) => !CUCS_TO_IGNORE.includes(Math.round(val.cucId)));
+    }
+    return date;
+  }
+
+
+}

package/projects/tuki/widgets/user-manage/src/services/site-settings.service.ts

@@ -0,0 +1,35 @@
+import { Injectable, OnInit } from '@angular/core';
+import { APIService } from './api.service';
+import { API } from '../app.constants';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+const urlMap = {
+  locations: API.LOCATION,
+  userLocales: API.USER_LOCALES,
+  userProfiles: API.USER_PROFILES
+}
+
+@Injectable()
+export class SiteSettingsService {
+
+  constructor(
+    private apiService: APIService
+  ) {
+
+  }
+  public getSelectionOptions(siteId: number, token: string): any {
+    if(!siteId) {
+      return;
+    }
+    // @ts-ignore
+    const URL = urlMap[token];
+    return this.apiService.fetch(URL.replace(':siteId', String(siteId)), null, true)
+      // @ts-ignore
+      .pipe(map((options: string[]) => {
+        // @ts-ignore
+        this[token] = options ? options.sort() : [];
+        // @ts-ignore
+        return this[token];
+      }))
+  }
+}

package/projects/tuki/widgets/user-manage/src/services/sorting-utils.service.ts

@@ -0,0 +1,203 @@
+import { Injectable } from '@angular/core';
+import { LineAssociationInterface } from '../classes/line-association-interface';
+import { DeviceInterface } from '../classes/device';
+import { LineInterface } from '../classes/line';
+import { LineAssociation } from '../classes/line-association';
+
+const string_array = function (original: string[], updated: string[], fullKey: string) {
+  if (!updated || !SortingUtilsService.differs(original, updated)) {
+    return null;
+  }
+  return `${fullKey}=${updated.join(',')}`;
+};
+
+const line_reference = function (original: string[], updated: string[], fullKey: string) {
+  if (!updated || !SortingUtilsService.differs(original, updated)) {
+    return null;
+  }
+  // @ts-ignore
+  return Object.keys(updated).map(key => `${fullKey}.${key}=${updated[key]}`);
+};
+
+const nullable = function (original: string[], updated: string[], fullKey: string) {
+  if (!original && updated) {
+    // @ts-ignore
+    return Object.keys(updated).map(key => `${fullKey}.${key}=${updated[key]}`);
+  } else if (original && !updated) {
+    return `${fullKey}=null`;
+  } else {
+    return SortingUtilsService.diff(original, updated, fullKey, []);
+  }
+};
+
+@Injectable()
+export class SortingUtilsService {
+
+  static dictionary = {
+    features: string_array,
+    services: string_array,
+    directoryNumber: line_reference,
+    primaryLineReference: line_reference,
+    speedDials: function (original: any, updated: any, fullKey: string) {
+      if (!updated || !SortingUtilsService.differs(original, updated)) {
+        return null;
+      }
+      // todo only changes, identification
+      let map: any = [];
+      updated.map((speedDial: any) => {
+        const currentFullKey = `${fullKey}.${speedDial.index}`; // ${speedDial.type} CHECk ?
+        map = [...map, Object.keys(speedDial).map(key => `${currentFullKey}.${key}=${speedDial[key]}`)];
+      });
+      return map;
+    },
+    lineAssociations: function (original: LineAssociationInterface[], updated: LineAssociationInterface[], fullKey: string) {
+      if (!updated || !SortingUtilsService.differs(original, updated)) {
+        return null;
+      }
+      let map: any = [];
+      updated.map((lineAssociation: LineAssociationInterface) => {
+        const currentFullKey = `${fullKey}.${lineAssociation.linePkid ? lineAssociation.linePkid : lineAssociation.lineLocalId}`;
+        const originalLineAssociation = original.find(line => line.index === lineAssociation.index);
+        if (SortingUtilsService.differs(originalLineAssociation, lineAssociation)) {
+          const diff = SortingUtilsService.diff(originalLineAssociation, lineAssociation, currentFullKey, []);
+          map = [...map, ...diff];
+        }
+      });
+      return map;
+    },
+    enterpriseAltNum: nullable,
+    e164AltNum: nullable
+  };
+
+  public static sortDevicesByTypeAndName(array: Array<DeviceInterface>): any {
+    if (!array) {
+      return null;
+    }
+    return array.sort((a, b) => {
+      if (a.deviceType === b.deviceType) {
+        return (a.name < b.name) ? -1 : (a.name > b.name) ? 1 : 0;
+      } else {
+        return (a.deviceType < b.deviceType) ? -1 : 1;
+      }
+    });
+  }
+
+  static sortLinesByDirectoryName(array: LineInterface[]): any {
+    if (!array) {
+      return null;
+    }
+    return array.sort((a, b) => {
+      if (!a.directoryNumber && !b.directoryNumber) {
+        return 0;
+      }
+      if (a.directoryNumber && !b.directoryNumber) {
+        return 1;
+      }
+      if (!a.directoryNumber && b.directoryNumber) {
+        return -1;
+      }
+      const directoryNumberA = a.directoryNumber.directoryNumber;
+      const directoryNumberB = b.directoryNumber.directoryNumber;
+      return (directoryNumberA < directoryNumberB) ? -1 : (directoryNumberA > directoryNumberB) ? 1 : 0;
+    });
+  }
+
+  static sortLineAssociationsByPosition(array: LineAssociation[]): any {
+    if (!array) {
+      return null;
+    }
+    return array.sort((a, b) => {
+      if (!a.position && !b.position) {
+        return 0;
+      }
+      if (a.position && !b.position) {
+        return 1;
+      }
+      if (!a.position && b.position) {
+        return -1;
+      }
+      const positionA = a.position;
+      const positionB = b.position;
+      return (positionA < positionB) ? -1 : (positionA > positionB) ? 1 : 0;
+    });
+  }
+
+  static sortSortArrayByProperty(array: any, sortBy: string): any {
+    if (!array) {
+      return null;
+    }
+    return array.sort((a: any, b: any) => {
+      if (!a[sortBy] && !b[sortBy]) {
+        return 0;
+      }
+      if (a[sortBy] && !b[sortBy]) {
+        return 1;
+      }
+      if (!a[sortBy] && b[sortBy]) {
+        return -1;
+      }
+      const positionA = a[sortBy];
+      const positionB = b[sortBy];
+      return (positionA < positionB) ? -1 : (positionA > positionB) ? 1 : 0;
+    });
+  }
+
+
+  static diff(origObject: any, updatedObj: any, path: string, keysToIgnore: any) {
+    let result: any = [];
+    if (Object.is(origObject, updatedObj)) {
+      return undefined;
+    }
+    if (!updatedObj || typeof updatedObj !== 'object') {
+      return updatedObj;
+    }
+    const concat = Array.from(new Set([...Object.keys(origObject || {}), ...Object.keys(updatedObj || {})]));
+    const filter = keysToIgnore ? concat.filter(key => !keysToIgnore.includes(key)) : concat;
+    filter
+      .forEach(key => {
+        // @ts-ignore
+        if (this.dictionary[key]) {
+          // @ts-ignore
+          const complexResult = this.dictionary[key](origObject[key], updatedObj[key], `${path}${path ? '.' : ''}${key}`);
+          if (complexResult) {
+            if (Array.isArray(complexResult)) {
+              result = [...result, ...complexResult];
+            } else {
+              result.push(complexResult);
+            }
+          }
+        } else if (typeof updatedObj[key] === 'object' && typeof origObject[key] === 'object') {
+          if (SortingUtilsService.differs(updatedObj[key], origObject[key])) {
+            const newPath = `${path}${path ? '.' : ''}${key}`;
+            const values = SortingUtilsService.diff(origObject[key], updatedObj[key], newPath, keysToIgnore);
+            if (values !== undefined) {
+              result = [...result, ...values];
+            }
+          }
+        } else if (updatedObj && !origObject || updatedObj[key] !== origObject[key] && !Object.is(origObject[key], updatedObj[key])) {
+          const value = updatedObj ? SortingUtilsService.formatIfEmpty(updatedObj[key]) : null;
+          result.push(`${path}${path ? '.' : ''}${key}=${value}`);
+        }
+      });
+    return result;
+  }
+
+  static formatIfEmpty(value: any): any {
+    if (value) {
+      return value;
+    }
+    switch (typeof value) {
+      case 'boolean':
+        return value;
+      case 'string':
+        return '';
+      default:
+        return null;
+    }
+  }
+
+  static differs(obj1: any, obj2: any): boolean {
+    return JSON.stringify(obj1) !== JSON.stringify(obj2);
+  }
+
+}