@tuki-io/tuki-widgets 0.0.73 → 0.0.74

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

@@ -0,0 +1,82 @@
+import { Injectable } from '@angular/core';
+import { APIService } from './api.service';
+import { API } from '../app.constants';
+import { map } from 'rxjs/operators';
+import { SiteDefaults, SiteTemplateInterface } from './../classes/site-defaults';
+const urlMap = {
+  locations: API.LOCATION,
+  userLocales: API.USER_LOCALES,
+  userProfiles: API.USER_PROFILES,
+  recordingProfile: API.RECORDING_PROFILE,
+}
+
+@Injectable()
+export class SiteSettingsService {
+  deviceSoftkeyTemplates!: string[];
+  siteDefaults!: SiteDefaults;
+  originalSiteDefaults!: SiteDefaults;
+  deviceTypes!: any;
+  routePartitionNames!: any;
+  filteredRoutePartitionNames!: any;
+  allRoutePartitionNames!: any;
+  directoryNumbers!: any;
+  options!: any;
+
+  get callingSearchSpaceTypes() {
+    return this.siteDefaults?.cssFilter || [];
+  }
+
+  get devicePools() {
+    return this.siteDefaults?.devicePoolFilter || [];
+  }
+
+  constructor(
+    private apiService: APIService
+  ) {
+    this.options = {};
+  }
+  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)))
+      .pipe(map((res: string[]) => {
+        this.options[token] = res;
+        return this.options;
+      }));
+  }
+
+  public getDeviceSoftkeyTemplates(siteId: number): any {
+    // @ts-ignore
+    return this.apiService.fetch(API.SOFTKEY_TEMPLATES.replace(':siteId', String(siteId)), null, false)
+      .pipe(map((templates: string[]) => this.deviceSoftkeyTemplates = templates));
+    // .pipe(this.handleError(false, true));
+  }
+
+  public getSiteDefaults(siteId: number, directAccess?: boolean, sharedLineSiteIds?: string): any {
+    /*const params = {directAccess: directAccess};
+    if (sharedLineSiteIds) {
+      // @ts-ignore
+      params['sharedLineSiteIds'] = sharedLineSiteIds;
+    }*/
+    return this.apiService.fetch(API.SITE_SETTINGS.replace(':siteId', String(siteId)), {})
+      .pipe(map((siteDefaults: SiteTemplateInterface) => {
+        this.siteDefaults = new SiteDefaults(siteDefaults, !!sharedLineSiteIds);
+        const copiedSiteDefaults = JSON.parse(JSON.stringify(siteDefaults));
+        this.originalSiteDefaults = new SiteDefaults(copiedSiteDefaults, !!sharedLineSiteIds);
+      }))
+    // .pipe(this.handleError(true, true));
+  }
+
+  public getMonitorCss(siteId: number): any {
+    return this.apiService.fetch(API.DEVICE_LINE_MONITOR_CSS.replace(':siteId', String(siteId)), null)
+      // .pipe(this.handleError(false, true));
+  }
+
+  public getRecordingProfile(siteId: number): any {
+    return this.apiService.fetch(API.RECORDING_PROFILE.replace(':siteId', String(siteId)), null)
+      // .pipe(this.handleError(false, true));
+  }
+}

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

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

@@ -0,0 +1,283 @@
+import {Injectable, OnInit} from '@angular/core';
+import { Observable, of, forkJoin, Subject } from 'rxjs';
+import { SimplifiedUser } from './../classes/simplified-user';
+import { API } from '../app.constants';
+import { APIService } from './api.service';
+import { map } from 'rxjs/operators';
+import { UtilsService } from './utils.service';
+import { LineAssociation } from './../classes/line-association';
+import { LineAssociationInterface } from './../classes/line-association-interface';
+import { LineService } from './line.service';
+import { SortingUtilsService } from './sorting-utils.service';
+import { ValidationService } from './validation.service';
+import { Device } from './../classes/device';
+
+@Injectable()
+export class UserService implements OnInit{
+  siteId: number = -1;
+  userId: string = '';
+  userIdExistPending = false;
+  hasExistedUserId = false;
+  user!: SimplifiedUser;
+  originUser!: SimplifiedUser;
+  onUserLineSaved$ = new Subject<any>();
+  onFetchUserToken$ = new Subject<any>();
+
+  get lineAssociation(): LineAssociation | LineAssociationInterface {
+    return this.user?.devices[0].lineAssociations[0];
+  }
+
+  get originLineAssociation(): LineAssociation | LineAssociationInterface {
+    return this.originUser?.devices[0].lineAssociations[0];
+  }
+
+  constructor(
+    private apiService: APIService,
+    private lineService: LineService
+  ) {
+
+  }
+
+  ngOnInit(): void {
+    console.log(this.siteId)
+  }
+
+  resetLineAssociation(deviceIndex: number, lineIndex: number, validationService: ValidationService): void {
+    const originLine = this.originUser?.devices[deviceIndex]?.lineAssociations[lineIndex];
+    if (this.user?.devices[deviceIndex]?.lineAssociations[lineIndex] && originLine) {
+      this.user.devices[deviceIndex].lineAssociations[lineIndex] = new LineAssociation(JSON.parse(JSON.stringify(originLine.getFullData())), validationService)
+    }
+  }
+
+  resetDevice(currentDevice: Device, validationService: ValidationService): void {
+    const originDevice = this.originUser.devices.find(device => device.name === currentDevice.name);
+    const deviceInd = this.user.devices.findIndex(device => device.name === currentDevice.name);
+    if (originDevice && deviceInd > -1) {
+      const lineAssociations = this.user.devices[deviceInd].lineAssociations;
+      this.user.devices[deviceInd] = new Device(JSON.parse(JSON.stringify(originDevice.getNoLinesFullData())), validationService);
+      this.user.devices[deviceInd].lineAssociations = lineAssociations;
+      console.log('device after reset = ', this.user.devices[deviceInd]);
+    }
+  }
+
+  public fetchUserToken(siteId: number, userId: string, validationService: ValidationService, isSetNewTokenOnly?: boolean): any {
+    /*if (this.siteId === siteId && this.userId === userId && this.user) {
+      return of(this.user);
+    }*/
+    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 user = result && Object.values(result)[0];
+        const userToken = result && Object.keys(result)[0];
+        if (user) {
+          if (!isSetNewTokenOnly) {
+            this.setSimplifiedUser(user, validationService, userToken);
+          } else {
+            this.user.token = user.token;
+            this.originUser.token = user.token;
+          }
+          this.onFetchUserToken$.next(true);
+        }
+
+      }))
+    // .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 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 fetchLeanUserConversationById(id: string) {
+    return this.apiService.fetch(API.LEAN_USER_CONVERSATION_START.replace(':siteId', String(this.siteId)).replace(':userId', encodeURIComponent(encodeURIComponent(id))));
+  }
+
+  public fetchLeanUserDevicesConversationById(id: string) {
+    return this.apiService.fetch(API.LEAN_USER_DEVICES_CONVERSATION_START.replace(':siteId', String(this.siteId)).replace(':userId', encodeURIComponent(encodeURIComponent(id))));
+  }
+  public fetchLeanUserLinesConversationById(id: string, leanUserDevicesToken: string) {
+    return this.apiService.fetch(API.LEAN_USER_LINES_CONVERSATION_START.replace(':siteId', String(this.siteId))
+      .replace(':userId', encodeURIComponent(encodeURIComponent(id))).replace(':leanUserDevicesToken', leanUserDevicesToken));
+  }
+  public fetchLeanUserSNRConversationById(id: string) {
+    return this.apiService.fetch(API.LEAN_USER_SNR_CONVERSATION_START.replace(':siteId', String(this.siteId)).replace(':userId', encodeURIComponent(encodeURIComponent(id))));
+  }
+
+  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), {}, {})
+          .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.getUserDetailsSavableData(), this.user.getUserDetailsSavableData(), 'user');
+    if (body?.length) {
+      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 saveNewLine(validationService: ValidationService): any {
+    this.deleteLine(this.user.siteId, this.lineAssociation.linePkid, encodeURIComponent(this.user.token))
+      .subscribe(() => {
+        const URL = API.PERSIST_USER_CACHE.replace(':siteId', String(this.siteId)).replace(':token', this.user.token);
+        this.apiService.post(URL, {}, )
+          .subscribe(() => {
+            this.fetchUserToken(this.siteId, this.user.userid, validationService, true)
+              .subscribe(() => {
+                this.runNewLineCreation();
+              });
+          });
+      });
+  }
+
+  public persistUserCache(): any {
+    const URL = API.PERSIST_USER_CACHE.replace(':siteId', String(this.siteId)).replace(':token', this.user.token);
+    return this.apiService.post(URL, {}, );
+  }
+
+  public runNewLineCreation(): void {
+    // CREATE NEW LINE
+    const newLineBody = SortingUtilsService.diff(
+      this.lineService.generateLineAssociationFromLine(null),
+      this.lineService.generateLineAssociationFromLine(this.lineAssociation),
+      'device.lineAssociations', null
+    );
+    this.associateLineToUserDevice(
+      this.user.siteId,
+      this.user.devices[0].name,
+      newLineBody,
+      null,
+      this.lineAssociation.callingSearchSpace
+    ).subscribe((response: any) => {
+      if (response?.currentUpdatedUser) {
+        const linePkId = response.currentUpdatedUser.devices[0]?.lineAssociations[0]?.linePkid || response.currentUpdatedUser.devices[0]?.lineAssociations[0]?.lineLocalId;
+        forkJoin([
+          this.updateLineFields(this.siteId, linePkId, this.user.token, this.lineAssociation.alertingName),
+          this.updateDeviceFields(this.siteId, this.user.devices[0]?.name, this.user.token)
+        ]).subscribe((response: any) => {
+          this.originUser.devices[0].lineAssociations[0].directoryNumber.directoryNumber = this.lineAssociation.directoryNumber.directoryNumber;
+          this.onUserLineSaved$.next(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));
+  }
+
+  public updateDeviceFields(siteId: number, deviceName: string, token: string) {
+    const body = ['device.associatedDNs.0=null'];
+    return this.apiService.post(API.UPDATE_DEVICE_FIELDS.replace(':siteId', String(siteId)).replace(':deviceName', deviceName).replace(':token', encodeURIComponent(token)), body)
+    // .pipe(this.handleError(true, false));
+  }
+
+  public checkDestinationNumber(siteId: string, directoryNumber: string, routePartitionName: string) {
+    const params = {
+      dntype: 'EXTENSION'
+    };
+    const body = {
+      directoryNumber: directoryNumber,
+      routePartitionName: routePartitionName
+    };
+    return this.apiService.post(API.CHECK_DESTINATION_NUMBER.replace(':siteId', siteId), body, params);
+  }
+
+  public associateLineToUserDevice(siteId: number, deviceName: string, body: any, pkid: any, css: any) {
+    let params = {};
+    if (pkid) {
+      params = {linePkid: pkid};
+    }
+    if (css) {
+      // @ts-ignore
+      params['css'] = css;
+    }
+    return this.apiService.post(API.ASSOCIATE_LINE.replace(':siteId', String(siteId)).replace(':deviceName', deviceName)
+      .replace(':token', encodeURIComponent(this.user.token)), body, params)
+      // .pipe(this.handleError(true, true));
+  }
+
+  public hasUnsavedChanges() {
+    if (this.user && this.originUser) {
+      return !this.user.equal(this.originUser);
+    }
+    return false;
+  }
+
+  public setSimplifiedUser(user: any, validationService: ValidationService, userToken?: string): void {
+    this.user = new SimplifiedUser(user, validationService);
+    const copiedUser = JSON.parse(JSON.stringify(user));
+    this.originUser = new SimplifiedUser(copiedUser, validationService);
+    if (!this.user.token && userToken) {
+      this.user.token = userToken;
+      this.originUser.token = userToken;
+    }
+  }
+
+  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/user-device-manage/src/services/utils.service.ts

@@ -0,0 +1,87 @@
+import { Injectable } from '@angular/core';
+
+@Injectable()
+export class UtilsService {
+
+  static filterOptions(options: any[], query: string, shownValue?: any, field?: string)  {
+    if (!options) {
+      return [];
+    }
+    if (!query) {
+      return options;
+    }
+    return options.filter(option => {
+      return (
+        field ? String(option[field]).toLowerCase().includes(String(query).toLowerCase()) :
+          String(option).toLowerCase().includes(String(query).toLowerCase()) ||
+          (shownValue && shownValue === option)
+      );
+    });
+  };
+
+  static sortSortArrayByProperty(array: [], sortBy: string) {
+    if (!array) {
+      return null;
+    }
+    return array.sort((a, b) => {
+      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?: string[]) {
+    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 => {
+        if (typeof updatedObj[key] === 'object' && typeof origObject[key] === 'object') {
+          if (UtilsService.differs(updatedObj[key], origObject[key])) {
+            const newPath = `${path}${path ? '.' : ''}${key}`;
+            const values = UtilsService.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 ? UtilsService.formatIfEmpty(updatedObj[key]) : null;
+          result.push(`${path}${path ? '.' : ''}${key}=${value}`);
+        }
+      });
+    return result;
+  }
+
+  static formatIfEmpty(value: 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);
+  }
+}