@tuki-io/tuki-widgets 0.0.133 → 0.0.134

package/projects/tuki/widgets/users-list/src/services/dns.service.ts

@@ -0,0 +1,128 @@
+import { Injectable } from '@angular/core';
+import { API } from '../app.constants';
+import { APIService } from './api.service';
+import { map } from 'rxjs/operators';
+import * as Big from 'big.js';
+import { Observable } from 'rxjs';
+import { ApiWebexService } from '../services/api-webex.service';
+import { AvailablePhoneNumberRangeInterface, DnRangeType } from '../classes/line';
+
+
+@Injectable()
+export class DnsService {
+  availableNumbers = {};
+  availableDidPatternsMappedToDn!: any;
+  phoneNumbers: string[] = [];
+
+  constructor(
+    private apiService: APIService,
+    private apiWebexService: ApiWebexService
+  ) {
+
+  }
+  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;
+    });
+  }
+
+  public fetchPhoneNumbers(customerId: number, locationId: string): any {
+    const params = {
+      available: true,
+      numberType: 'NUMBER'
+    };
+    return this.apiWebexService.fetch(API.PHONE_NUMBERS.replace(':customerId', String(customerId)).replace(':locationId', locationId), params)
+      .pipe(map((result: any) => {
+        if (result?.length) {
+          this.phoneNumbers = result.map((item: any) => item.phoneNumber);
+        }
+        return result;
+      }));
+  }
+}

package/projects/tuki/widgets/users-list/src/services/events-communication.service.ts

@@ -0,0 +1,11 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+
+@Injectable()
+export class EventsCommunicationService {
+  public onSuccessfulLoginEvent = new Subject();
+
+  constructor() {
+  }
+
+}

package/projects/tuki/widgets/users-list/src/services/move-user.service.ts

@@ -0,0 +1,59 @@
+import { Injectable } from '@angular/core';
+import { APIService } from './api.service';
+import { ApiWebexService } from '../services/api-webex.service';
+import { API } from '../app.constants';
+import { map } from 'rxjs/operators';
+import { MigrationData, PrepareMigrationBody, PrepareMigrationData } from '../classes/move-user';
+import { Observable } from 'rxjs';
+
+@Injectable()
+export class MoveUserService {
+  prepareMigrationData!: PrepareMigrationData;
+  originPrepareMigrationData!: PrepareMigrationData;
+
+  constructor(
+    private apiService: APIService,
+    private apiWebexService: ApiWebexService
+  ) {
+
+  }
+
+  resetMigrationDataForNewLocation(): void {
+    this.prepareMigrationData.newExtension = '';
+    this.prepareMigrationData.newPhoneNumber = '';
+    this.prepareMigrationData.newExtension = '';
+
+  }
+
+  setOriginPrepareMigrationData(): void {
+    const data = JSON.parse(JSON.stringify(this.prepareMigrationData.getSavableData()));
+    this.originPrepareMigrationData = new PrepareMigrationData(data);
+  }
+
+  fetchPrepareMigrationData(data: PrepareMigrationBody): any {
+    return this.apiWebexService.post(API.PREPARE_PERSON_MIGRATION, data.getSavableData())
+      .pipe(map((result: any) => {
+        if (result) {
+          this.prepareMigrationData = new PrepareMigrationData(result, this.originPrepareMigrationData);
+        }
+        return result;
+      }));
+    // .pipe(this.handleError(false, true));
+  }
+
+  startMigration(data: MigrationData): any {
+   /* return new Observable<boolean>(observer => {
+      setTimeout(() => {
+        observer.next(true);
+
+      }, 2000);
+    });*/
+    return this.apiWebexService.post(API.START_MIGRATION, data.getSavableData())
+      .pipe(map((result: any) => {
+        if (data) {
+          this.prepareMigrationData = new PrepareMigrationData(data);
+        }
+      }));
+    // .pipe(this.handleError(false, true));
+  }
+}

package/projects/tuki/widgets/users-list/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/users-list/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/users-list/src/services/site-settings.service.ts

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import { API } from '../app.constants';
+import { map } from 'rxjs/operators';
+import { AppLocation } from '../classes/app-location';
+import { ApiWebexService } from '../services/api-webex.service';
+
+@Injectable()
+export class SiteSettingsService {
+  locations: AppLocation[] = [];
+
+  constructor(
+    private apiWebexService: ApiWebexService
+  ) {
+
+  }
+
+  getLocations(customerId: number): any {
+    return this.apiWebexService.fetch(API.GET_LOCATIONS.replace(':customerId', String(customerId)), {})
+      .pipe(map((result: any) => {
+        if (result && result.length) {
+          this.locations = result.map((location: any) => new AppLocation(location))
+        }
+        return result;
+      }))
+  }
+}

package/projects/tuki/widgets/users-list/src/services/user.service.ts

@@ -0,0 +1,159 @@
+import {Injectable, OnInit} from '@angular/core';
+import { Observable, of, forkJoin, Subject } from 'rxjs';
+import { SimplifiedUser } from '../classes/simlified-user';
+import { API } from '../app.constants';
+import { APIService } from './api.service';
+import { map } from 'rxjs/operators';
+import { UtilsService } from '../utils/utils.service';
+import { ListUser } from '../classes/user-list';
+import { ApiWebexService } from './api-webex.service';
+
+@Injectable()
+export class UserService implements OnInit{
+  siteId: number = -1;
+  userId: string = '';
+  userIdExistPending = false;
+  hasExistedUserId = false;
+  user!: SimplifiedUser;
+  originUser!: SimplifiedUser;
+  moveUserPending = false;
+  userMoved$ = new Subject<any>();
+
+  constructor(
+    private apiService: APIService,
+    private apiWebexService: ApiWebexService
+  ) {
+
+  }
+
+  ngOnInit(): void {
+    console.log(this.siteId)
+  }
+
+  public fetchUserToken(siteId: number, userId: string): any {
+    this.siteId = siteId;
+    this.userId = userId;
+    return this.apiService.fetch(API.USER_TOKEN.replace(':siteId', String(this.siteId)).replace(':userId', encodeURIComponent(encodeURIComponent(userId))))
+      .pipe(map((result: any) => {
+        const token = Object.keys(result)[0];
+        this.setSimplifiedUser(Object.values(result)[0], token);
+      }))
+    // .pipe(this.handleError(false, true));
+  }
+
+  public updateUserFields(body: any): any {
+    if (!this.userId || !this.siteId || !this.user?.token) {
+      return;
+    }
+    return this.apiService.post(API.UPDATE_USER_FIELDS.replace(':siteId', String(this.siteId)).replace(':token', this.user.token), body)
+      // .pipe(this.handleError(false, true));
+  }
+
+  public moveUserToMT(customerId: any, user: ListUser): any {
+    // return new Observable<boolean>(observer => {
+    //   setTimeout(() => {
+    //     observer.next(true);
+    //
+    //   }, 1000);
+    // });
+    return this.apiWebexService.post(API.MOVE_USER, this.getMoveUserBody(customerId, user))
+    // .pipe(this.handleError(true, true));
+  }
+
+  public moveUserToDI(customerId: any, user: ListUser): any {
+    // return new Observable<boolean>(observer => {
+    //   setTimeout(() => {
+    //     observer.next(true);
+    //
+    //   }, 1000);
+    // });
+    const URL = API.REVERT_WEBEX_USER.replace(':customerId', customerId).replace(':webexUUID', String(user.webexUUID));
+    return this.apiWebexService.post(URL, this.getMoveUserBody(customerId, user))
+    // .pipe(this.handleError(true, true));
+  }
+
+  private getMoveUserBody(customerId: any, user: ListUser): any {
+    return {
+      customerId: customerId,
+      entities: {
+        PERSON: [{cucmId: user.cucmId, entityId: user.userid}]
+      }
+    };
+  }
+
+  public deleteUser(siteId: number, userId: string): Observable<any> {
+    return this.apiService.delete(API.DELETE_USER.replace(':siteId', String(siteId)).replace(':userId', encodeURIComponent(encodeURIComponent(userId))))
+      // .pipe(this.handleError(true, true));
+  }
+
+  public fetchUserById(id: string) {
+    this.userIdExistPending = true;
+    return this.apiService.fetch(API.USER_BY_ID.replace(':siteId', String(this.siteId)).replace(':userId', encodeURIComponent(encodeURIComponent(id))))
+      .pipe(map(result => {
+        this.userIdExistPending = false;
+        return result;
+      }));
+  }
+
+  public persistCacheChanges() {
+    const params = {
+      excludeDeviceExtraOptions: true
+    };
+    return this.processUserChangesToCache()
+      .pipe(map((result: any) => {
+        return this.apiService.post(API.PERSIST_USER_CACHE.replace(':siteId', String(this.siteId)).replace(':token', this.user.token), {}, params)
+          .subscribe(() => {
+
+          })
+          // .pipe(map((user) => {
+          //   // this.setUser(user, false, this.user.token);
+          //   this.user.hasModifiedCache = false;
+          // }))
+          // .pipe(this.handleError(true, true));
+      }));
+  }
+
+  public processUserChangesToCache(): any {
+    const calls = [];
+    const body = UtilsService.diff(this.originUser.getSavableData(), this.user.getSavableData(), 'user');
+    if (body) {
+      calls.push(this.updateUserFields(body));
+    }
+    if (!calls?.length) {
+      return of(this.user);
+    }
+
+    return forkJoin(calls)
+      .pipe(map((responses: any) => {
+        // ApiUserResponse
+        this.handleSaveUserResponse(responses);
+      }))
+      // .pipe(this.handleError(false, true));
+
+  }
+
+  public hasUnsavedChanges() {
+    return !this.user.equal(this.originUser);
+  }
+
+  public setSimplifiedUser(user: any, token?: any): void {
+    this.user = new SimplifiedUser(user);
+    const copiedUser = JSON.parse(JSON.stringify(user));
+    this.originUser = new SimplifiedUser(copiedUser);
+    this.user.token = this.user.token || token;
+    this.originUser.token = this.originUser.token || token;
+  }
+
+  private handleSaveUserResponse(responses: any) {
+    if (!responses?.length) {
+      return;
+    }
+    for (let len = responses.length, i = len - 1; i >= 0; i--) {
+      if (responses[i] && responses[i].currentUpdatedUser) {
+        // this.setUser(responses[i].currentUpdatedUser, false, this.user.token);
+        this.user.hasModifiedCache = true;
+        return;
+      }
+    }
+  }
+}

package/projects/tuki/widgets/users-list/src/services/users-search.service.ts

@@ -0,0 +1,160 @@
+import { Injectable, OnInit } from '@angular/core';
+import { SimplifiedUser } from '../classes/simlified-user';
+import { APIService } from './api.service';
+import { ListUser, ListUserInterface } from '../classes/user-list';
+import { BehaviorSubject, Observable, of } from 'rxjs';
+import { API, PAGINATION_DEFAULTS, PAGINATION_SIZE_OPTIONS, MAX_INTEGER } from '../app.constants';
+import { TableDataInterface } from '../classes/table-data';
+import { map } from 'rxjs/operators';
+import { RemoveKynFromIBMService } from './removeKynFromIBM.service';
+import { PaginationDataDto } from '../classes/pagination';
+import { ApiWebexService } from './api-webex.service';
+
+
+
+@Injectable()
+export class UsersSearchService  {
+  siteId: number = -1;
+  userId: string = '';
+  customerId!: number;
+  siteid!: number;
+  userIdExistPending = false;
+  hasExistedUserId = false;
+  pageSize = PAGINATION_DEFAULTS.SIZE;
+  pageIndex = PAGINATION_DEFAULTS.SIZE;
+  pageSizeOptions = PAGINATION_SIZE_OPTIONS;
+  migratedUsersIds!: any;
+  total!: number;
+  migratedUsers!: any;
+  searchParams!: any;
+  foundUsers$!: any;
+
+  constructor(
+    private apiService: APIService,
+    private webexApiService: ApiWebexService,
+    private removeKynFromIBMService: RemoveKynFromIBMService
+  ) {
+    this.foundUsers$ = new BehaviorSubject(null);
+
+  }
+
+  public getAllRegularUsers(searchParams?: any): Observable<ListUser[]> {
+    const params = searchParams || {customerid: this.customerId, siteid: this.siteId};
+    return this.apiService.fetchPagination(API.QUICK_USERS_SEARCH, MAX_INTEGER, 0, params)
+      .pipe(map((res: TableDataInterface) => {
+        const users = res.pageData && res.pageData.length ? res.pageData
+          .map(user => new ListUser(user, user.webexUUID ? '' : 'Dedicated Instance Calling User')) : [];
+        if (this.migratedUsersIds?.length) {
+          this.setMigratedPropToUsers(users);
+        }
+        return users;
+      }));
+  }
+
+  public getPagination(): PaginationDataDto {
+    return {
+      total: this.total,
+      pageSizeOptions: this.pageSizeOptions,
+      pageSize: this.pageSize,
+      pageIndex: this.pageIndex
+    };
+  }
+
+  public setDefaultValues() {
+    this.total = 0;
+    this.pageSize = PAGINATION_DEFAULTS.SIZE;
+    this.pageIndex = PAGINATION_DEFAULTS.INDEX;
+    this.pageSizeOptions = PAGINATION_SIZE_OPTIONS;
+  }
+  public quickRegularUsersSearch(searchParams?: any, isMigratedUsersOnly?: boolean, pageSize?: number): any {
+    console.log('searchParams = ', searchParams);
+    this.searchParams = searchParams || {customerid: this.customerId, siteid: this.siteId};
+    // this.searchParams['provisionType'] = 'CUCM';
+    return this.apiService.fetchPagination(API.QUICK_USERS_SEARCH, this.pageSize, pageSize ||this.pageIndex, this.searchParams)
+      .pipe(map((res: TableDataInterface) => {
+        // this.totals = this.totals || {};
+        // this.totals['users'] = res.total;
+
+        // this.foundUsers$.next(this.removeKynFromIBMService.removeCUCMS(users, this.customerId));
+        if (!isMigratedUsersOnly) {
+          const users = res.pageData && res.pageData.length ? res.pageData
+            .map(user => new ListUser(user)) : [];
+          if (this.migratedUsersIds?.length) {
+            this.setMigratedPropToUsers(users);
+          }
+          this.total = res.total;
+          this.foundUsers$.next(users);
+        } else {
+          this.migratedUsersIds = res.pageData && res.pageData.length ? res.pageData
+            .map(user => user.userid) : [];
+        }
+      }));
+      // .pipe(this.handleError(true));
+  }
+
+  public quickWebexUsersSearch(searchParams?: any, isMigratedUsersOnly?: boolean, pageSize?: number): any {
+    this.searchParams = searchParams || {customerid: this.customerId, siteid: this.siteId};
+    // this.searchParams['provisionType'] = 'CUCM';
+    return this.webexApiService.fetchPagination(API.QUICK_USERS_SEARCH, this.pageSize, pageSize ||this.pageIndex, this.searchParams)
+      .pipe(map((res: TableDataInterface) => {
+        console.log('data: ', res);
+        
+        if (!isMigratedUsersOnly) {
+          const users = res.pageData && res.pageData.length ? res.pageData
+            .map(user => new ListUser(user)) : [];
+          if (this.migratedUsersIds?.length) {
+            this.setMigratedPropToUsers(users);
+          }
+          this.total = res.total;
+          this.foundUsers$.next(users);
+        } else {
+          this.migratedUsersIds = res.pageData && res.pageData.length ? res.pageData
+            .map(user => user.userid) : [];
+        }
+      }));
+    // .pipe(this.handleError(true));
+  }
+
+  getMigratedUsers(customerId: number): any {
+    this.migratedUsers = [];
+    return of(this.migratedUsers);
+    // return this.webexApiService.fetch(API.WEBEX_USERS.replace(':customerId', String(customerId)), {})
+    //   .pipe(map((result: any) => {
+    //     if (result && result.length) {
+    //       this.migratedUsers = result.filter((user: any) => user.webexUUID && user.devices && user.devices.length);
+    //     }
+    //   }))
+  }
+
+  getMigratedWebexUsers(customerId: number): any {
+    const params = {customerid: customerId, type: 'PERSON'};
+    return this.webexApiService.fetch(API.MIGRATED_USERS.replace(':customerId', String(customerId)), params, true)
+      .pipe(map((result: any) => {
+      }))
+  }
+
+  setMigratedPropToUsers(users: any): void {
+    // users.forEach((user: any) => {
+    //   const migratedUser = this.migratedUsers.filter((migratedUser: any) => migratedUser.userid === user.email);
+    //   if (migratedUser && migratedUser[0]) {
+    //     user.roleName = '';
+    //     user.isMigrated = true;
+    //     user.status = 'Migrated';
+    //     user.webexUUID = migratedUser[0].webexUUID;
+    //   } else {
+    //     user.roleName = 'Dedicated Instance Calling user';
+    //     user.isMigrated = false;
+    //     user.status = 'Active';
+    //     user.webexUUID = null;
+    //   }
+
+    //   if (user.webexUUID) {
+    //     user.roleName = 'Dedicated Instance Calling user';
+    //   } else {
+    //     user.roleName = '';
+    //    }
+    // })
+    // console.log('users ttt', users);
+  }
+
+}