@tuki-io/tuki-widgets 0.0.95 → 0.0.97

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

@@ -0,0 +1,829 @@
+import { Injectable } from '@angular/core';
+import { SiteSettingsService } from './site-settings.service';
+import { DeviceTypes, MailboxQuotasType, SpeedDialType, VMNotificationsTypes } from './../classes/types';
+import { Device, DeviceKind } from './../classes/device';
+
+const speedDialRegex = new RegExp('^[^"]*$');
+const BLFRegex = new RegExp('^[^"><&%]*$');
+const timeRegex = new RegExp('^([0-1][0-9]|[2][0-3]):([0-5][0-9])$');
+
+@Injectable()
+export class ValidationService {
+
+  constructor(
+    private siteSettingsService: SiteSettingsService,
+  ) {
+  }
+
+  e164MaskLabel(control: any) {
+    const ruleText = `^[0-9*#+X]{0,24}$`;
+    const rule = new RegExp(ruleText, 'g');
+    if (control.value && rule && !rule.test(control.value)) {
+      return {e164MaskRule: {rule: ruleText}};
+    }
+    return null;
+  }
+
+  index(control: any) {
+    const value = parseInt(control.value);
+    if (!value) {
+      return null;
+    }
+    const pattern = '^[+0-9]*$';
+    if (value && !Number.isInteger(value) || value < 1 || value > 199) {
+      return {indexRule: true};
+    }
+    return null;
+  }
+
+  displayLabel(control: any) {
+    const ruleText = `^[^""""%&<>]{0,30}$`;
+    const rule = new RegExp(ruleText, 'g');
+    if (rule && !rule.test(control.value)) {
+      return {labelRule: {rule: ruleText, count: 30}};
+    }
+    return null;
+  }
+
+
+
+  displayLabelAscii(control: any) {
+    const ruleText = '^[a-zA-Z0-9 !#$\'()*+,./:;=?@\\^_`}~-]{0,30}$';
+    const rule = new RegExp(ruleText, 'g');
+    if (rule && !rule.test(control.value)) {
+      return {labelRule: {rule: ruleText, count: 30}};
+    }
+    return null;
+  }
+
+  requiredForSpeedDialPosition(type: string) {
+
+    return (control: any) => {
+      const parent = control.parent;
+      if (type === SpeedDialType.slotBasic || !parent) {
+        return null;
+      }
+      if (!control.value) {
+        return {required: true};
+      }
+      return null;
+    };
+  }
+
+  speedDialDestination() {
+    return (control: any) => {
+      if (!control || !control.value) {
+        return null;
+      }
+      const numberOrHostNameIP = '' +
+        '^([0-9\\*#+PpCcFf,]+)$' +
+        '|' +
+        '^(' +
+        '([a-zA-Z0-9]){1,47}@' +
+        '(' +
+        '((?:[0-9]{1,3}\\.){3}[0-9]{1,3})' +
+        '|' +
+        '([a-zA-Z0-9][a-zA-Z0-9\\-]{1,61}[a-zA-Z0-9]\\.[a-zA-Z]{2,})' +
+        ')' +
+        ')$';
+      const rule = new RegExp(numberOrHostNameIP, 'g');
+      if (rule && !rule.test(control.value)) {
+        return {pattern: true};
+      }
+      return null;
+    };
+
+  }
+
+  requiredForSpeedDialDestination(type: string) {
+
+    return (control: any) => {
+      const parent = control.parent;
+      if ((!parent || !parent.get('label')) || (type === SpeedDialType.slotBasic && !control.value && !parent.get('label').value)) {
+        return null;
+      }
+      return null;
+    };
+  }
+
+
+  labelPatternDependingOnType(control: any) {
+    const parent = control?.parent;
+    if (!parent || !parent.get('type') || !control.value) {
+      return null;
+    }
+    const type = parent.get('type').value;
+    if (!type && !speedDialRegex.test(control.value)) {
+      return {labelRule: {wrong: '"'}};
+    }
+    if (type && !BLFRegex.test(control.value)) {
+      return {labelRule: {wrong: '"><&%'}};
+    }
+    return null;
+  }
+
+  labelPatternBLF(control: any) {
+    if (control.value && !BLFRegex.test(control.value)) {
+      return {labelRule: {wrong: '"><&%'}};
+    }
+    return null;
+  }
+
+  labelPatternSpeedDial(control: any) {
+    if (control?.value && !speedDialRegex.test(control.value)) {
+      return {labelRule: {wrong: '"'}};
+    }
+    return null;
+  }
+
+  matchControl = (fieldName: string) => {
+    return (control: any) => {
+      if (!control?.parent) {
+        return null;
+      }
+      const matchingControl = control.parent.get(fieldName);
+      if (matchingControl.value && matchingControl.value !== control.value) {
+        return {
+          matchControl: true
+        };
+      }
+      return null;
+    };
+  };
+
+  matchLength = (fieldName: string) => {
+    return (control: any) => {
+      if (!control.parent || !control.value) {
+        return null;
+      }
+      const matchingControl = control.parent.get(fieldName);
+      if (((!control.value.startsWith('+') && !matchingControl.value.startsWith('+')) ||
+        (control.value.startsWith('+') && matchingControl.value.startsWith('+'))) &&
+        ((!control.value.startsWith('\\+') && !matchingControl.value.startsWith('\\+')) ||
+          (control.value.startsWith('\\+') && matchingControl.value.startsWith('\\+'))) &&
+        matchingControl.value.length !== control.value.length) {
+        return {
+          matchLength: true
+        };
+      }
+      return null;
+    };
+  };
+
+  dynamicMaxLength = (length1: number, length2: number) => {
+    return (control: any) => {
+      if (!control.parent || !control.value) {
+        return null;
+      }
+      const maxLength = String(control.value).includes('[') ? length1 : length2;
+      if (control.value.length > maxLength) {
+        return {
+          maxLength: true
+        };
+      }
+      return null;
+    };
+  };
+
+  biggerThan = (fieldName: string) => {
+    return (control: any) => {
+      if (!control.parent || !control.value) {
+        return null;
+      }
+      const matchingControl = control.parent.get(fieldName);
+      if (matchingControl.value.length === control.value.length && matchingControl.value && matchingControl.value > control.value) {
+        return {
+          biggerThan: true
+        };
+      }
+      return null;
+    };
+  };
+
+  requiredByType = (fieldName: string, type: string) => {
+    return (control: any) => {
+      if (
+        fieldName === 'phoneSystem' && (type === VMNotificationsTypes['Phone Device'] || type === VMNotificationsTypes['Pager Device']) ||
+        fieldName === 'htmlTemplate' && type === VMNotificationsTypes['HTML Device']
+      ) {
+        return {
+          required: true
+        };
+      }
+      return null;
+    };
+  };
+
+  smallerThanQuota = (fieldName: string, quotaType: string, secondQuotaType: string) => {
+    return (control: any) => {
+      if (!control.parent) {
+        return null;
+      }
+      const matchingControl = control.parent.get(fieldName);
+      const quotaTypeControl = control.parent.get(quotaType);
+      const secondQuotaTypeControl = control.parent.get(secondQuotaType);
+
+      if (quotaTypeControl && secondQuotaTypeControl && secondQuotaTypeControl.value === MailboxQuotasType.system) {
+        return null;
+      }
+
+      if (quotaTypeControl && quotaTypeControl.value === MailboxQuotasType.system || matchingControl && matchingControl.value && parseInt(matchingControl.value) < parseInt(control.value)) {
+        return {
+          smallerThan: true
+        };
+      }
+      return null;
+    };
+  };
+
+  biggerThanQuota = (fieldName: string, quotaType: string) => {
+    return (control: any) => {
+      if (!control?.parent) {
+        return null;
+      }
+      const matchingControl = control.parent.get(fieldName);
+      const quotaTypeControl = control.parent.get(quotaType);
+
+      if (quotaTypeControl && quotaTypeControl.value === MailboxQuotasType.custom && matchingControl.value && parseInt(matchingControl.value) > parseInt(control.value)) {
+        return {
+          biggerThan: true
+        };
+      }
+      return null;
+    };
+  };
+
+  rangeLimit = (fieldName: string) => {
+    return (control: any) => {
+      if (!control?.parent || !control.value) {
+        return null;
+      }
+      const matchingControl = control.parent.get(fieldName);
+      if ((control.value - matchingControl.value) > 50000) {
+        return {
+          rangeLimit: true
+        };
+      }
+      return null;
+    };
+  };
+
+  comparepatternParts = (fieldName: string) => {
+    return (control: any) => {
+      if (!control?.value) {
+        return null;
+      }
+      const matches = control.value.match(/\[(.*?)\]/);
+      if (matches) {
+        const submatch = matches[1];
+        const submatchsplit: number[] = submatch.split('-');
+        for (let i = 0; i < submatchsplit.length; i++) {
+          if (submatchsplit[i] >= submatchsplit[i + 1]) {
+            return {
+              comparepatternParts: true
+            };
+          }
+        }
+      }
+      return null;
+    };
+  };
+
+  matchPrefix = (fieldName: string) => {
+    return (control: any) => {
+      if (!control?.parent || !control.value) {
+        return null;
+      }
+      const matchingControl = control.parent.get(fieldName);
+      if ((matchingControl.value.startsWith('+') || control.value.startsWith('+') || matchingControl.value.startsWith('\\+') || control.value.startsWith('\\+')) && (control.value.charAt(0) !== matchingControl.value.charAt(0))) {
+        return {
+          matchPrefix: true
+        };
+      }
+      return null;
+    };
+  };
+
+  deviceNameValidator = (device: Device) => {
+    return (control: any) => {
+      if (!control.value || device.deviceKind === DeviceKind.deviceProfile) {
+        return;
+      }
+      if (device.isCtiRoutePoint) {
+        let err = '';
+        if (!control.value.match(/^[a-zA-Z0-9-_.]+$/)) {
+          err = 'pattern';
+        }
+        if (control.value.trim().length > 15) {
+          err = 'maxLength';
+        }
+        return err ? {nameRule: err} : null;
+      }
+      if (device.deviceDefaults && !device.isCtiRoutePoint) {
+        const ruleText = device.deviceDefaults.deviceNameRegex;
+        const rule = new RegExp(ruleText, 'g');
+        const caption = device.deviceDefaults?.deviceNameExplained;
+        const match = (control.value || '').match(rule) || [];
+        const exactMatch = match && control.value === match[0];
+        if (rule && !exactMatch) {
+          return {nameRule: {caption}};
+        }
+      }
+      return null;
+    };
+  };
+
+  deviceNameValueValidator = (device: Device, deviceName: string) => {
+    return (control: any) => {
+      if (!control.value || device.deviceKind === DeviceKind.deviceProfile) {
+        return;
+      }
+      if (device.name && device.alreadyUsedName && device.name === device.alreadyUsedName) {
+        return {nameRule: 'alreadyUsedName'};
+      }
+      if (device.isCtiRoutePoint) {
+        let err = '';
+        if (!deviceName.match(/^[a-zA-Z0-9-_.]+$/)) {
+          err = 'pattern';
+        }
+        if (deviceName.trim().length > 15) {
+          err = 'maxLength';
+        }
+        return err ? {nameRule: err} : null;
+      }
+     if (device.deviceDefaults && !device.isCtiRoutePoint) {
+       const ruleText = device.deviceDefaults.deviceNameRegex;
+        // console.log('Dev name rule - ', ruleText);
+        const rule = new RegExp(ruleText, 'g');
+        let caption = device.deviceDefaults.deviceNameExplained;
+        if (!caption) {
+          caption = ruleText;
+        }
+        const match = (deviceName || '').match(rule) || [];
+        const exactMatch = match && deviceName === match[0];
+        if (rule && !exactMatch) {
+          return {nameRule: {caption}};
+        }
+      }
+      return null;
+    };
+  };
+
+  deviceDuplicatingNameValidator = (user: any, pkid ?: string, prefix?: string) => {
+    return (control: any) => {
+      if (!control.value || !user || !user.devices || user.devices.length === 0) {
+        return;
+      }
+      const deviceName = prefix ? `${prefix}${control.value}` : control.value;
+      const devicesWithTheSameName = user.devices.filter((device: Device) => device.name === deviceName);
+      if (devicesWithTheSameName.length > 0) {
+        if (!pkid) {  // For new device
+          return {duplicateNameRule: true};
+        } else if (pkid !== devicesWithTheSameName[0].pkid) { // For updating device, avoid validating with itself
+          return {duplicateNameRule: true};
+        }
+      }
+      return null;
+    };
+  };
+
+  conditionalRequired = (fieldName: string, requiredConditionValues: any[]) => {
+    return (control: any) => {
+      const parent1 = control.parent;
+      if (!parent1 || !parent1.get(fieldName) || !parent1.get(fieldName).value) {
+        return;
+      }
+      if (requiredConditionValues.includes(parent1.get(fieldName).value) && !control.value) {
+        return {
+          required: true
+        };
+      }
+      return null;
+    };
+  };
+
+  conditionalRequiredForGroupAdmin = (fieldName: string, requiredConditionValues: any[]) => {
+    return (control: any) => {
+      const parent1 = control.parent;
+      if (!parent1 || !parent1.get(fieldName) || !parent1.get(fieldName).value || !parent1.get(fieldName).value.type) {
+        return;
+      }
+      if (requiredConditionValues.includes(parent1.get(fieldName).value.type) && !control.value) {
+        return {
+          required: true
+        };
+      }
+      return null;
+    };
+  };
+
+  conditionalSiteGroupCheckForGroupAdmin = (fieldName: string, requiredConditionValues: any[]) => {
+    return (control: any) => {
+      const parent1 = control.parent;
+      if (!parent1 || !parent1.get(fieldName) || !parent1.get(fieldName).value || !parent1.get(fieldName).value.type) {
+        return;
+      }
+      if (parent1.get(fieldName).value && requiredConditionValues.includes(parent1.get(fieldName).value.type) &&
+        parent1.get('siteGroup') && parent1.get('siteGroup').value &&
+        parent1.get('siteGroup').value.siteGroupMembers && parent1.get('siteGroup').value.siteGroupMembers.length < 1) {
+        return {
+          hasSiteGroupError: true
+        };
+      }
+      return null;
+    };
+  };
+
+  requiredIfFieldIsEmptyForBLF = (fieldName: any) => {
+    const DATE_PATTERN = '^(0[1-9]|1[012])[- \/.](0[1-9]|[12][0-9]|3[01])[- \/.](19|20)\d\d$';
+    return (control: any) => {
+      const parent = control.parent;
+      if (!parent || !parent.get(fieldName)) {
+        return null;
+      }
+      if (!parent.get(fieldName).value && !control.value) {
+        return {
+          requiredEither: true,
+          requiredBLFDN: true
+        };
+      }
+      return null;
+    };
+  };
+
+
+  validDate = (fieldName: string) => {
+
+    return (control: any) => {
+      const parent = control.parent;
+      const ruleText = '^(0[1-9]|1[012])[- \/.](0[1-9]|[12][0-9]|3[01])[- \/.](19|20)\d\d$';
+      const rule = new RegExp(ruleText, 'g');
+      const val = control.value && control.value.getDate();
+      if (rule && !rule.test(val)) {
+        return {pattern: true};
+      }
+      return null;
+    };
+  };
+
+
+  matchOption = (optionType: string, list?: any, isFullList?: boolean) => {
+    return (control: any) => {
+      if (!control.value || control.value === DeviceTypes.CTI_ROUTE_POINT) {
+        return null;
+      }
+      let optionList = list || this.getOptionsList(optionType);
+      if (optionList && optionList.length) {
+        if (!isFullList && optionType === 'directoryNumbers') {
+          optionList = optionList.map((str: string) => str.indexOf(' ') > -1 ? str.substring(0, str.indexOf(' ')) : str);
+        }
+        if (!optionList.includes(control.value)) {
+          return {
+            matchOptions: true
+          };
+        }
+      }
+      return null;
+    };
+  };
+
+  confidentialAccessLevel = (confidentialAccessMode: string) => {
+    return (control: any) => {
+      if (!control.value && !confidentialAccessMode) {
+        return null;
+      }
+      if (!control.value) {
+        return {
+          required: true
+        };
+      }
+      return null;
+    };
+  };
+
+  noResultDN = (optionType: string, list?: any) => {
+    return (control: any) => {
+      if (!control.value || list === null) {
+        return null;
+      }
+      if (list && list.length === 0) {
+        return {
+          noResultDNs: true
+        };
+      }
+      return null;
+    };
+  };
+
+  matchExtensionOption = (optionType: string, optionList?: any) => {
+    return (control: any) => {
+      if (!control.value) {
+        return control.value;
+      }
+      // @ts-ignore
+      const newList = [];
+      if (optionList && optionList.length) {
+        optionList.forEach((list: any) => {
+          const newOptionList = this.getMatchExistingVmLineValue(list);
+          newList.push(newOptionList);
+        });
+        // @ts-ignore
+        if (newList && !newList.includes(control.value)) {
+          return {
+            matchOptions: true
+          };
+        }
+      } else if (!optionList || !optionList.length) {
+        return {
+          matchOptions: true
+        };
+      }
+      return null;
+    };
+  };
+
+  public getMatchExistingVmLineValue(dnWithType: string): string {
+    const ind = dnWithType.indexOf('Type:');
+    let dn = dnWithType;
+    if (ind > -1) {
+      dn = dnWithType.slice(0, ind);
+      dn = dn.trim();
+    }
+    return dn;
+  }
+
+  requiredEitherForVmExtension = (fieldName1: string, fieldName2: string) => {
+    return (control: any) => {
+      if (!control.parent) {
+        return null;
+      }
+      const matchControl1 = control.parent.get(fieldName1).value;
+      const matchControl2 = control.parent.get(fieldName2).value;
+      if (!matchControl1 && !matchControl2) {
+        return {
+          requiredEitherForVmExtension: true
+        };
+      }
+      return null;
+    };
+  };
+
+  requiredEitherOne = (fieldName1: string, fieldName2: string) => {
+    return (control: any) => {
+      if (!control.parent) {
+        return null;
+      }
+      const matchControl1 = control.parent.get(fieldName1) && control.parent.get(fieldName1).value;
+      const matchControl2 = control.parent.get(fieldName2) && control.parent.get(fieldName2).value;
+      if (!matchControl1 && !matchControl2) {
+        return {
+          requiredEitherOne: true
+        };
+      }
+      return null;
+    };
+  };
+
+  requiredByValue = (fieldName: string, requestedFieldVal: any) => {
+    return (control: any) => {
+      if (!control || !control.parent) {
+        return null;
+      }
+      const fieldVal = control.parent.get(fieldName) && control.parent.get(fieldName).value;
+      if (fieldVal && fieldVal === requestedFieldVal && !control.value) {
+        return {
+          required: true
+        };
+      }
+      return null;
+    };
+  };
+
+  OneExtensionEmpty = (fieldName1: string, fieldName2: string) => {
+    return (control: any) => {
+      if (!control.parent) {
+        return null;
+      }
+      const matchControl1 = control.parent.get(fieldName1).value;
+      const matchControl2 = control.parent.get(fieldName2).value;
+      if (matchControl1 && matchControl2) {
+        return {
+          OneExtensionIsEmpty: true
+        };
+      }
+      return null;
+    };
+  };
+
+  requiredByCondition = (requiredBy: string, fieldName: any) => {
+    return (control: any) => {
+      if (!control.parent) {
+        return null;
+      }
+      const requiredByControl = control.parent.get(requiredBy).value;
+      const requiredControl = control.parent.get(fieldName).value;
+      if (requiredByControl && !requiredControl) {
+        return {
+          required: true
+        };
+      }
+      return null;
+    };
+  };
+
+  private getOptionsList(token: string): string[] {
+    switch (token) {
+      case 'css':
+      case 'rerouteCss':
+      case 'callingSearchSpace':
+        return this.siteSettingsService.callingSearchSpaceTypes;
+      case 'reroutingCss':
+        return this.siteSettingsService.siteDefaults && this.siteSettingsService.siteDefaults.cssFilter;
+      case 'deviceType':
+        return this.siteSettingsService.deviceTypes;
+      case 'routePartition':
+        return this.siteSettingsService.routePartitionNames;
+      case 'routePartitionFiltered':
+        return this.siteSettingsService.filteredRoutePartitionNames;
+      case 'devicePools':
+        return this.siteSettingsService.devicePools;
+      case 'allRoutePartitions':
+        return this.siteSettingsService.allRoutePartitionNames;
+      case 'directoryNumbers':
+        return this.siteSettingsService.directoryNumbers;
+      default:
+        return [];
+    }
+  }
+
+  autocompleteType(control: any) {
+    if (!control.value) {
+      return null;
+    }
+    if (typeof control.value !== 'object' && control.value !== '') {
+      return {
+        stringEntered: true
+      };
+    }
+    return null;
+  }
+
+
+  password(control: any) {
+    const ruleNumeric = new RegExp(/\d+/, 'g');
+    const ruleCapitals = new RegExp(/[A-Z]+/, 'g');
+    const ruleSmall = new RegExp(/[a-z]+/, 'g');
+    const ruleSpecial = new RegExp(/[!@#$%&\/=\?_\.,:;\-\\+]+/, 'g');
+
+    const hasNumeric = +ruleNumeric.test(control.value);
+    const hasCapitals = +ruleCapitals.test(control.value);
+    const hasSmall = +ruleSmall.test(control.value);
+    const hasSpecial = +ruleSpecial.test(control.value);
+
+    if (hasNumeric + hasCapitals + hasSmall + hasSpecial < 3) {
+      return {
+        weakPassword: true
+      };
+    }
+
+    return null;
+  }
+
+  verifyAutoAnswer(control: any) {
+    if (!control?.value || control.value.length === 0) {
+      return null;
+    }
+    let autoAnswerErrorLine = null;
+    if (control.parent && control.parent.parent && control.parent.parent.parent && control.parent.parent.parent.parent) {
+      const controlSNR = control.parent;
+      const controlUser = control.parent.parent.parent.parent;
+      const lineAssociations = controlSNR.get('lineAssociations');
+      const lines = controlUser.get('lines');
+      if (lines) {
+        lineAssociations.value.forEach((lineAssociation: any) => {
+          const autoAnswerLine = lines.controls.find((line: any) => line.get('directoryNumber').value.directoryNumber === lineAssociation.directoryNumber && line.get('directoryNumber').value.routePartitionName === lineAssociation.routePartitionName
+            && line.get('autoAnswer').value !== 'Auto Answer Off');
+          if (autoAnswerLine) {
+            autoAnswerErrorLine = {
+              autoAnswerErrorLine: lineAssociation.directoryNumber
+            };
+          }
+        });
+      }
+    }
+
+    return autoAnswerErrorLine;
+  }
+
+  verifyBeginEndTime(control: any) {
+    const parent = control.parent;
+    if (!parent || !parent.get('isActive') || !parent.get('allDay') || !parent.get('from') || !parent.get('to')) {
+      return null;
+    }
+
+    if (parent.get('isActive').value) {
+      if (!parent.get('allDay').value) {
+        if (!parent.get('from').value || parent.get('from').value === 'No Office Hours'
+          || !parent.get('to').value || parent.get('to').value === 'No Office Hours'
+          || parent.get('from').value > parent.get('to').value) {
+          return {
+            fromGreaterThanTo: true
+          };
+        }
+      }
+    }
+
+    return null;
+  }
+
+  time(control: any) {
+    if (control.value && !timeRegex.test(control.value)) {
+      return {timeFormat: true};
+    }
+    return null;
+  }
+
+
+  pinMultiCharacterCheck = (fieldName: string) => {
+    // @ts-ignore
+    return (control: any) => {
+      if (!control.parent) {
+        return null;
+      }
+      const matchingControl = control.parent.get(fieldName);
+      const ruleMultiCharacter = new RegExp('([0-9])\\1{2}');
+      if (matchingControl.value) {
+        const hasMultiCharacter = ruleMultiCharacter.test(matchingControl.value);
+        if (hasMultiCharacter) {
+          return {
+            multiCharacter: true
+          };
+        }
+      }
+    };
+  };
+
+  pinConsecutiveNumberCheck = (fieldName: string) => {
+    // @ts-ignore
+    return (control: any) => {
+      if (!control.parent) {
+        return null;
+      }
+      const matchingControl = control.parent.get(fieldName);
+      const strToCheck = matchingControl.value;
+      if (strToCheck && strToCheck.length > 1) {
+        const resAsc = this.pinOrderCheck(strToCheck);
+        if (resAsc === true) {
+          return {
+            consecutiveNumbers: true
+          };
+        }
+      }
+    };
+  };
+
+
+  pinOrderCheck(str: string): any {
+    if (str) {
+      const arr_num = ('' + str).split('');
+      for (let i = 0; i < arr_num.length - 2; i++) {
+        const num1 = parseInt(arr_num[i]);
+        const num2 = parseInt(arr_num[i + 1]);
+        const num3 = parseInt(arr_num[i + 2]);
+        if ((num2 - num1) === 1 && (num3 - num2 === num2 - num1)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+
+
+  pinMailboxExtensionCheck = (fieldName: string, extension: string) => {
+    return (control: any) => {
+      if (!control.parent) {
+        return null;
+      }
+      const matchingControl = control.parent.get(fieldName);
+      const strToCheck = matchingControl.value;
+      if (strToCheck === extension || strToCheck.includes(extension)) {
+        return {
+          mailboxExtension: true
+        };
+      }
+      return null;
+    };
+  };
+
+  isItemAlreadyInList(item: any, list: any): boolean {
+    if (!item || !list || !list.length) {
+      return false;
+    }
+    for (const listItem of list) {
+      if (item.equals(listItem)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}