@tuki-io/tuki-widgets 0.0.73 → 0.0.74

package/projects/tuki/widgets/user-device-manage/src/notifications/notification.component.scss

@@ -0,0 +1,84 @@
+@import '../styles/variables';
+
+.notification-block {
+  right: 0;
+  top: 110px;
+  position: absolute;
+  width: 20%;
+  z-index: 100;
+
+  .read-more-error {
+    margin: 10px 13px 3px 0;
+    text-align: right;
+  }
+
+  .notification {
+    padding: 15px 0 10px 0;
+    margin-bottom: 18px;
+    color: $main-txt-color;
+    position: relative;
+    border-radius: 3px;
+    border-top: 1.5px solid $warning-border-color;
+    background: $warning-bg-color;
+    box-shadow: 0px 8px 12px 0px rgba(9, 30, 66, 0.15), 0px 0px 1px 0px rgba(9, 30, 66, 0.31);
+    width: 368px;
+    position: relative;
+
+    .notification-icons-block {
+      text-align: center;
+      width: 56px;
+    }
+    .message-block {
+      font-size: 14px;
+      font-family: $poppins-font !important;
+      word-break: break-word;
+      width: 270px;
+    }
+    .notification-icon-close {
+      height: 24px;
+    }
+
+    &.error {
+      background: #FFE9E9;
+      border-top: 1.5px solid #E16D6D;
+    }
+    &.success {
+      background: $success-bg-color;
+      border-top: 1.5px solid $success-border-color;
+    }
+    .fa-exclamation-triangle {
+      color: #E16D6D !important;
+    }
+    .fa-check {
+      color: #a0c37f !important;
+    }
+    .fa-info-circle, .fa-hand-paper-o {
+      color: #bdb89e !important;
+    }
+    .fa {
+      font-size: 20px;
+    }
+    .close {
+      position: absolute;
+      top: 2px;
+      right: -5px;
+      .fa {
+        font-size: 14px;
+      }
+    }
+    .fa {
+      margin: 0;
+      color: inherit;
+    }
+  }
+}
+
+@media screen and (max-width: 600px) {
+  .notification-block {
+    width: 50%;
+    min-width: 150px;
+  }
+
+}
+
+

package/projects/tuki/widgets/user-device-manage/src/notifications/notification.component.ts

@@ -0,0 +1,46 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, OnDestroy, OnInit } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { NotificationService } from '../services/notification.service';
+import { Notification } from '../classes/notification';
+
+@Component({
+  selector: 'app-notification',
+  templateUrl: './notification.component.html',
+  styleUrls: ['./notification.component.scss'],
+  changeDetection: ChangeDetectionStrategy.OnPush
+})
+export class NotificationsComponent implements OnInit, OnDestroy {
+  public list!: Notification[];
+  public isReadMore!: boolean;
+  private listSubscription!: Subscription;
+
+  constructor(
+    public notificationService: NotificationService,
+    private ref: ChangeDetectorRef
+  ) {
+  }
+
+  ngOnInit() {
+    this.listChangeSubscribe();
+  }
+
+  ngOnDestroy() {
+    this.listSubscription.unsubscribe();
+  }
+
+  public readMore(): void {
+    this.isReadMore = !this.isReadMore;
+  }
+
+  public removeNotification(notification: Notification): void {
+    this.notificationService.remove(notification);
+  }
+
+  private listChangeSubscribe(): void {
+    this.listSubscription = this.notificationService.listChange
+      .subscribe((list: any) => {
+        this.list = list;
+        this.ref.detectChanges();
+      });
+  }
+}

package/projects/tuki/widgets/user-device-manage/src/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-device-manage/src/services/api.service.ts

@@ -0,0 +1,87 @@
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+
+@Injectable()
+export class APIService {
+  public token: any;
+  apiUrl = window.location.protocol + '//' + window.location.hostname + '/dcp';
+  constructor(
+    private httpClient: HttpClient
+  ) {
+  }
+
+  fetch(url: string, params?: any, cache?: boolean): Observable<any> {
+    const headers = this.getHeaders(cache);
+    params = params || {};
+    return this.httpClient.get(this.apiUrl + url, {params: this.prepareEncodedParams(params), headers});
+  }
+
+  post(url: string, body: any, params = {}): any {
+    body = body || null;
+    const headers = this.getHeaders();
+    return this.httpClient.post(this.apiUrl + url, body, {params: this.prepareEncodedParams(params), headers});
+  }
+
+  // use when response extended data is necessary:
+  postExtended(url: string, body = null, params = {}, headers = {}) {
+    headers = headers || this.getHeaders();
+    return this.httpClient.post(this.apiUrl + url, body, {
+      headers,
+      observe: 'response',
+      params: this.prepareEncodedParams(params)
+    });
+  }
+
+  put(url: string, body = null, params = {}) {
+    const headers = this.getHeaders();
+    return this.httpClient.put(this.apiUrl + url, body, {headers, params: this.prepareEncodedParams(params)});
+  }
+
+  delete(url: string, params = {}) {
+    const headers = this.getHeaders();
+    return this.httpClient.delete(this.apiUrl + url, {headers, params: this.prepareEncodedParams(params)});
+  }
+
+  fetchPagination(url: string, pageSize: number, pageNumber: number, additionalParams = {}, cache?: boolean): Observable<any> {
+    const copyAdditionalParams = JSON.parse(JSON.stringify(additionalParams));
+    const params = Object.assign(copyAdditionalParams, {size: pageSize.toString(), page: pageNumber.toString()});
+    return this.fetch(url, params, cache) as Observable<any>;
+  }
+
+  private prepareEncodedParams(params: any) {
+    const result: any = {};
+
+    if (!params) {
+      return {};
+    }
+    for (const key of Object.keys(params)) {
+      if (params[key]) {
+        const stringParam = params[key].toString();
+        result[key] = stringParam.includes('+') ? encodeURIComponent(stringParam) : stringParam;
+      }
+    }
+    return result;
+  }
+
+  private getHeaders(cache?: boolean): HttpHeaders {
+    let headers = new HttpHeaders();
+    if (cache) {
+      headers = headers.append('_Cache', 'true ');
+    }
+    const token = this.token || this.getParameterByName('token');
+    headers = headers.append('Authorization', 'Bearer '+ token);
+    return headers;
+  }
+
+  private getParameterByName(name: any, url = window.location.href) {
+    name = name.replace(/[\[\]]/g, '\\$&');
+    var regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)'),
+      results = regex.exec(url);
+    if (!results) return null;
+    if (!results[2]) return '';
+    return decodeURIComponent(results[2].replace(/\+/g, ' '));
+  }
+
+}

package/projects/tuki/widgets/user-device-manage/src/services/common-functions.ts

@@ -0,0 +1,17 @@
+export const getSavableData = (model: any, exclude?: Array<string>) => {
+  let result = Object.keys(model);
+  if (exclude && exclude.length) {
+    result = result.filter(key => !exclude.some(item => item === key));
+  }
+  return result.reduce((result, key) => {
+    if (model[key] instanceof Array && model[key].length && model[key][0].getSavableData) {
+      (result as any)[key] = model[key].map((item: any) => item.getSavableData());
+    } else if (model[key] instanceof Object && model[key].getSavableData) {
+      (result as any)[key] = model[key].getSavableData();
+    } else {
+      (result as any)[key] = model[key];
+    }
+    return result;
+  }, {});
+};
+

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

@@ -0,0 +1,95 @@
+import { Injectable, OnInit } from '@angular/core';
+import { APIService } from './api.service';
+import { Observable, of, throwError } from 'rxjs';
+import { API } from '../app.constants';
+import { map } from 'rxjs/operators';
+import { SortingUtilsService } from './sorting-utils.service';
+import { Buttontemplate, Device } from '../classes/device';
+import { LineAssociationInterface } from '../classes/line-association-interface';
+
+@Injectable()
+export class DeviceService {
+  availableSlots!: number[];
+  lineSlotsList!: any;
+  availableLineSlotsList!: any;
+  dataPending = false;
+
+  constructor(
+    private apiService: APIService,
+  ) {
+  }
+
+  public hasUnsavedChanges(device: Device, originDevice: Device): boolean {
+    if (device?.lineAssociationsHasChanges) {
+      return true;
+    }
+    if (device && originDevice) {
+      return JSON.stringify(device.getSavableData()) !== JSON.stringify(originDevice.getSavableData());
+    }
+    return false;
+  }
+
+  public hasDeviceInfoUnsavedChanges(device: Device, originDevice: Device): boolean {
+    if (device && originDevice) {
+      return JSON.stringify(device.getDeviceInfoSavableData()) !== JSON.stringify(originDevice.getDeviceInfoSavableData());
+    }
+    return false;
+  }
+
+  public getDataToUpdateDevice(device: Device, originalDevice: Device) {
+    // --- to exclude newLines from update
+    // const devToUpdate = new Device(device, this.validationService);
+    // const originalDevToUpdate = new Device(originalDevice, this.validationService);
+    // // @ts-ignore
+    // devToUpdate.lineAssociations = devToUpdate.lineAssociations?.filter(line => line.linePkid);
+    // // @ts-ignore
+    // originalDevToUpdate.lineAssociations = originalDevToUpdate.lineAssociations?.filter(line => line.linePkid);
+
+    const body = SortingUtilsService.diff(originalDevice.getDeviceInfoSavableData(), device.getDeviceInfoSavableData(), 'device',
+      ['speedDials', 'busyLampFields']);
+    return body;
+  }
+
+  public fetchLeanUserDevicesConversationById(userId: string, siteId: number) {
+    return this.apiService.fetch(API.LEAN_USER_DEVICES_CONVERSATION_START.replace(':siteId', String(siteId)).replace(':userId', encodeURIComponent(encodeURIComponent(userId))));
+  }
+
+  public getSlotsByButtonTemplate(siteId: number, buttonTemplateName: string): Observable<Buttontemplate> {
+    return this.apiService.fetch(API.LINE_SLOTS.replace(':siteId', String(siteId)), {name: buttonTemplateName}, true)
+      // .pipe(this.handleError(true, true));
+  }
+
+  public putDeviceFields(siteId: number, deviceName: string, token: string, body: any) {
+    console.log('userToken = ', token);
+    const URL = API.UPDATE_DEVICE_FIELDS
+      .replace(':siteId', String(siteId))
+      .replace(':deviceName', deviceName)
+      .replace(':token', token);
+    console.log('url = ', URL);
+    return this.apiService.post(URL, body)
+      // .pipe(this.handleError(true, true));
+  }
+
+  public updateAvailableSlots(siteId: number, device: Device): any {
+    if (!device) {
+      throw throwError(() => new Error('test'));
+    }
+    if (!device.buttonTemplate) {
+      throw throwError(() => new Error('test'));
+    }
+    if (device.buttonTemplate === '') {
+      device.availableSlots = [];
+      return of(device);
+    }
+    const existingPositions = device.lineAssociations.map((lineAssociation: LineAssociationInterface) => lineAssociation.position);
+    return this.getSlotsByButtonTemplate(siteId, device.buttonTemplate)
+      .pipe(map((buttonTemplate: Buttontemplate) => {
+        this.lineSlotsList = buttonTemplate.lineSlots;
+        device.availableSlots = this.lineSlotsList.filter((position: number) => !existingPositions.includes(position));
+        this.availableLineSlotsList = device.availableSlots.slice();
+        return device;
+      }))
+      // .pipe(this.handleError(true, true));
+  }
+
+}

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

@@ -0,0 +1,111 @@
+import { Injectable } from '@angular/core';
+import { API } from '../app.constants';
+import { APIService } from './api.service';
+import { map } from 'rxjs/operators';
+import { AvailablePhoneNumberRangeInterface, DnRangeType } from './../classes/line';
+import * as Big from 'big.js';
+import { Observable } from 'rxjs';
+
+
+@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]?.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): string[] {
+    let unwrapNumberRange = this.unwrapNumberRange(availableNumber.phoneNumberRange.from, availableNumber.phoneNumberRange.to)
+      .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;
+  }
+
+  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-device-manage/src/services/line.service.ts

@@ -0,0 +1,89 @@
+import { Injectable } from '@angular/core';
+import { APIService } from './api.service';
+import { LineAssociation } from './../classes/line-association';
+import { API } from '../app.constants';
+import { SortingUtilsService } from './sorting-utils.service';
+import { Subject } from 'rxjs';
+import { LineAssociationInterface } from './../classes/line-association-interface';
+
+@Injectable()
+export class LineService {
+  line!: LineAssociation;
+  originLine!: LineAssociation;
+  currentActiveLinePkid!: string | null;
+  onSaveLineAssociationEvent = new Subject();
+
+  constructor(
+    private apiService: APIService
+  ) {
+
+  }
+  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'
+   }
+  }
+
+  hasUnsavedChanges(): boolean {
+    if (this.line && this.originLine) {
+      return JSON.stringify(this.line.getSavableData()) !== JSON.stringify(this.originLine.getSavableData())
+    }
+    return false;
+  }
+
+  generateLineDirectory(lineAssociation?: any): any {
+    return {
+      directoryNumber: lineAssociation.directoryNumber.directoryNumber,
+      routePartitionName: lineAssociation.directoryNumber.routePartitionName,
+    }
+  }
+
+  generateDidPatternForLineAssociation(lineAssociation?: any): any {
+    return {
+      calledPartyTransformationMask: lineAssociation.directoryNumber.directoryNumber
+    }
+  }
+
+  public checkLineDeletion(line: LineAssociation, siteId: number): any {
+    const params = {
+      extension: line.directoryNumber.directoryNumber,
+      routePartition: line.directoryNumber.routePartitionName,
+    };
+    return this.apiService.fetch(API.CHECK_DELETE_LINE.replace(':siteId', String(siteId)), params)
+      // .pipe(this.handleError(true, true));
+  }
+
+  public deleteLine(siteId: number, pkid: string, token: string) {
+    return this.apiService.delete(API.DELETE_LINE.replace(':siteId', String(siteId)).replace(':pkid', pkid).replace(':token', encodeURIComponent(token)), {})
+    // .pipe(this.handleError(true, false));
+  }
+
+  public disassociateLine(siteId: number, linePkid: string, token: string, deviceName: string) {
+    return this.apiService.delete(
+      API.DISASSOCIATE_LINE.replace(':siteId', String(siteId))
+        .replace(':linePkid', linePkid)
+        .replace(':deviceName', deviceName)
+        .replace(':token', encodeURIComponent(token)), {})
+    // .pipe(this.handleError(true, false));
+  }
+
+  public updateLineFields(siteId: number, pkid: string, token: string, alertingName: any) {
+    const body = ['line.description=', `line.alertingName=${alertingName}`];
+    return this.apiService.post(API.UPDATE_LINE_FIELDS.replace(':siteId', String(siteId)).replace(':pkid', encodeURIComponent(pkid)).replace(':token', encodeURIComponent(token)), body)
+    // .pipe(this.handleError(true, false));
+  }
+
+  getLineAssociationBody(originLineAssociation: LineAssociation | LineAssociationInterface, lineAssociation: LineAssociation | LineAssociationInterface) {
+    const body = SortingUtilsService.diff(originLineAssociation.getSavableData(), lineAssociation.getSavableData(),
+      `device.lineAssociations.${lineAssociation.linePkid}`, null);
+    return body;
+  }
+}

package/projects/tuki/widgets/user-device-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-device-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;
+  }
+
+
+}