@contrail/flexplm 1.5.0-alpha.98b8b06 → 1.5.0

package/src/util/data-converter.ts

@@ -0,0 +1,819 @@
+import { API_VERSION, Entities, TypeClientOptions } from '@contrail/sdk';
+import { TypeUtils } from './type-utils';
+import { FCConfig } from '../interfaces/interfaces';
+import { MapFileUtil } from '@contrail/transform-data';
+import { Logger } from '@contrail/app-framework';
+import { ObjectDiff, ObjectUtil } from '@contrail/util';
+import { TypeConversionUtils } from './type-conversion-utils';
+import { MapUtil } from './map-utils';
+import { ConfigDefaults } from './config-defaults';
+
+interface ObjectReferenceContext {
+  entityType: string;
+  entityTypePath: string;
+  rootTypeCriteria: Record<string, any>;
+  typeCriteria: Record<string, any>;
+  combinedCriteria: Record<string, any>;
+  cacheKey: string;
+  useIdentityService: boolean;
+  identityLookupKeys: string[];
+}
+
+export class DataConverter {
+  private typeUtils: TypeUtils;
+  private transformMapFile: string;
+  private useDisplayForEnumerationMatching = false;
+  private verboseDebug = false;
+  private objRefCache = {};
+  private userRefCache = {};
+  static staticUserCache = {};
+  static clearStaticUserCache() {
+    DataConverter.staticUserCache = {};
+  }
+  static getFromStaticCache(id: string) {
+    return DataConverter.staticUserCache[id];
+  }
+  static setToStaticCache(id: string, value: any) {
+    DataConverter.staticUserCache[id] = value;
+  }
+
+  constructor(private config: FCConfig, private mapFileUtil: MapFileUtil){
+    this.typeUtils = new TypeUtils();
+    this.transformMapFile = this.config['transformMapFile'];
+    this.useDisplayForEnumerationMatching = this.config['dataConverter']
+      && this.config['dataConverter']['useDisplayForEnumerationMatching'];
+    this.verboseDebug = this.config['dataConverter']
+      && this.config['dataConverter']['verboseDebug'];
+  }
+
+  public setVerboseDebug(val: boolean = false) {
+    this.verboseDebug= val;
+  }
+  public isVerboseDebugOn(): boolean {
+    return this.verboseDebug && Logger.isDebugOn();
+  }
+
+  async getFlexPLMObjectDataFromEvent(event, dataToSkip: string[]) {
+    return this.getFlexPLMObjectData(event.newData, dataToSkip, true);
+  }
+
+  async getFlexPLMObjectData(newData, dataToSkip: string[], inflateObjRef: boolean) {
+    if(this.isVerboseDebugOn()) {
+      console.debug('newData: ' + JSON.stringify(newData));
+    }
+    //Using event to get propertyDiffs to find emptied values
+    //Add standard atts to skip
+    dataToSkip = dataToSkip.concat(['updatedOn', 'updatedById', 'createdOn', 'createdById', 'modifiedAt', 'orgId', 'createdAt', 'id', 'typeId', 'workspaceId']);
+    // const oldData = event.oldData;
+    const data = {};
+    const typeId = newData?.typeId;
+    if (!typeId) {
+      return;// Don't have a type; so can't process
+    }
+    data['typePath'] = newData['typePath'];
+    const type = await this.typeUtils.getTypeById(typeId);
+    const typeProps = this.typeUtils.filterTypeProperties(type, newData);
+    for(const prop of typeProps){
+      // if(this.logger.isTraceOn()){
+      //   this.logger.log('prop: ' + JSON.stringify(prop));
+      // }
+      const slug = prop['slug'];
+      if (dataToSkip.includes(slug)) {
+        continue;
+      }
+      data[slug] = await this.getFlexPLMValue(prop, newData, inflateObjRef);
+    }
+
+    if(this.isVerboseDebugOn()) {
+      console.debug('getFlexPLMObjectData-data:  ' + JSON.stringify(data));
+    }
+    return data;
+
+  }
+
+  async getFlexPLMValue(prop, newData, inflateObjRef: boolean) {
+    const propertyType = prop['propertyType'];
+    const slug = prop['slug'];
+    const nd = newData[slug];
+    // console.log('getFlexPLMValue: ' + propertyType + ', ' +slug + ', ' + nd + ', ' + od);
+    let value;
+    if(['string', 'text'].includes(propertyType)){
+      value = nd || '';
+    }else if(['number', 'currency', 'percent', 'sequence'].includes(propertyType)){
+      value = nd || 0;
+    }else if('date' === propertyType){
+      if(nd){
+        value = nd;
+        // const d = new Date(nd);
+        // console.log('Date.getTimezoneOffset(): ' + d.getTimezoneOffset());
+        // value = d.toISOString();
+        // console.log('date: ' + nd + ' -- ' + value);
+      } else {
+        value = null;
+      }
+    }else if('boolean' === propertyType){
+      value =(nd)? true: false;
+    }else if('choice' === propertyType){
+      value = this.getEnumerationValue(prop, nd);
+    }else if('multi_select' === propertyType){
+      value = this.getEnumerationValue(prop, nd);
+    }else if('object_reference' === propertyType){
+      value = await this.getObjectReferenceValue(prop, newData, inflateObjRef);
+      if(this.isVerboseDebugOn()){
+        console.debug('object_reference: ' + JSON.stringify(value));
+      }
+    } else if ('image' === propertyType) {
+      // console.log('image-TODO');
+    }else if('formula' === propertyType){
+      value = nd;
+    }else if('json' === propertyType){
+      // console.log('json-TODO');
+      value = nd;
+    } else if ('userList' === propertyType) {
+      value = await this.getUserListValue(prop, newData);
+    }else if ('size_range' === propertyType){
+      value = nd;
+    }
+
+    return value;
+
+  }
+  /** Returns the display values for list properties (choice & multi_select)
+   *
+   * @param prop
+   * @param newData
+   * @returns
+   */
+  getEnumerationValue(prop, nd){
+    const propertyType = prop['propertyType'];
+    let value;
+    if(['choice', 'multi_select'].includes(propertyType)){
+      const options: [{value:string, display:string}] = prop['options'] || [];
+      if('choice' === propertyType){
+        if(nd){
+          const option = options.find(option => option.value == nd );
+          if(option){
+            value = Object.assign({},option);
+          }
+        }
+        if(!value) {
+          value = {};
+        }
+      } else if ('multi_select' === propertyType) {
+        value = [];
+        if (nd instanceof Array) {
+          nd.forEach(key => {
+            const optionObject = options.find(option => option.value == key);
+            if(optionObject){
+              const option = Object.assign({},optionObject);
+              value.push(option);
+            }
+          });
+        } else if( typeof nd === 'string' && '' !== nd) {
+          const optionObject = options.find(option => option.value == nd);
+          if(optionObject){
+            const option = Object.assign({},optionObject);
+            value.push(option);
+          }
+        }
+      }
+    }
+    return value;
+  }
+
+  public async getObjectReferenceValue(prop: any, newData: any, inflateObjRef = false) {
+    const slug = prop['slug'];
+    if(Logger.isDebugOn()) {
+      console.debug('getObjectReferenceValue-prop: ' + slug);
+    }
+    let value = newData[slug];
+    const entityType = prop['referencedTypeRootSlug'];
+    const entityId = newData[slug + 'Id'];
+    if ((!value || typeof value === 'string' )&& inflateObjRef) {
+      if (entityId) {
+        if(this.objRefCache[entityId]){
+          if(Logger.isDebugOn()) {
+            console.debug('cache hit: ' + entityId);
+          }
+          return this.objRefCache[entityId];
+        }
+        const criteria = {
+          id: entityId
+        };
+        const entities = await new Entities().get({
+          entityName: entityType,
+          criteria
+        });
+        value = (entities && entities[0]) ? entities[0] : undefined;
+      }
+    }
+
+    if(value && !(typeof value === 'string')){
+      const unprocessedValue = value;
+      const objectClass = await TypeConversionUtils.getObjectClass(this.transformMapFile, this.mapFileUtil, unprocessedValue);
+      const flexPLMTypePath = await TypeConversionUtils.getObjectTypePath(this.transformMapFile, this.mapFileUtil, unprocessedValue);
+      value = await this.getFlexPLMObjectData(value, [], false);
+      value['entityReference'] = entityType + ':' + entityId;
+      value['objectClass'] = objectClass;
+      value['flexPLMTypePath'] = flexPLMTypePath;
+
+      if(this.transformMapFile){
+        const mapKey = await TypeConversionUtils.getMapKey(this.transformMapFile, this.mapFileUtil, unprocessedValue, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+        value = await MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, value, mapKey, TypeConversionUtils.VIBE2FLEX_DIRECTION)
+      }
+
+    } else {
+      value = {};
+    }
+    this.objRefCache[entityId] = value;
+    return value;
+  }
+
+  /** (Deprecated) Use TypeConversionUtils.getMapKey()
+   * Will return the class to use to get mapping.
+   * This is needed because mappings will be different for different sub types
+   * of custom-entity
+   *
+   * @param obj: Entity being checked
+   * @param mapping: The whole mapping file
+   */
+  getMappingClass(entity: object, mapping: any): string{
+    const entityTypePath = entity['typePath'];
+    const typeMapKey = mapping['typeMapKey'];
+    let objClass = typeMapKey[entityTypePath];
+    const entityType = entity['entityType'];
+
+    if(!objClass){
+      objClass = this.typeUtils.getEventObjectClass(entityType, entity);
+    }
+    if(!objClass){
+      objClass = entityType;
+    }
+    return objClass;
+  }
+
+  /** Sets entity values from FlexPLM data passed in
+   * Assumes the entity has a VibeIQ typeId and 'roles' value to filter if necessary.
+   * @param entity the entity to update
+   * @param data the FlexPLM data
+   * @param keysToSkip properties to skip
+   * @returns the modified entity with VibeIQ values
+   */
+  async setEntityValues(entity, data, keysToSkip: string[] = []){
+    // this.logger.log('setEntityValues: ' + JSON.stringify(entity));
+    // this.logger.log('data: ' + JSON.stringify(data));
+    const type = await this.typeUtils.getTypeById(entity.typeId);
+    keysToSkip = keysToSkip.concat(['updatedOn', 'updatedById', 'createdOn', 'createdById', 'modifiedAt', 'orgId', 'createdAt', 'id', 'typeId', 'typePath', 'workspaceId']);
+    let typeProps = this.typeUtils.filterTypeProperties(type, entity);
+    typeProps = typeProps.filter( prop => !keysToSkip.includes(prop['slug']));
+    //Only process properties that had a value sent; to not accidentally clear out values
+    //for properties that weren't sent.
+    const dataKeys = Object.getOwnPropertyNames(data);
+    typeProps = typeProps.filter( prop => dataKeys.includes(prop['slug']));
+
+    for(const prop of typeProps){
+      const propertyType = prop['propertyType'];
+      const slug = prop['slug'];
+      let keyName = slug;
+      if (propertyType === 'userList' || propertyType === 'object_reference') {
+          keyName = slug + 'Id';
+      }
+      entity[keyName] = await this.getEntityValue(prop, data);
+      // console.log('entity[slug]: ' + entity[slug]);
+    }
+
+    return entity;
+
+  }
+
+  /** Gets the entity values from FlexPLM data
+   * Assumes there isn't a VibeIQ typeId, so uses FlexPLM data to determine type
+   * @param objectClass FlexPLM object class
+   * @param data object data
+   * @param keysToSkip type properties to not process
+   * @returns object with VibeIQ values
+   */
+  async getEntityValues(objectClass: string, data: any, keysToSkip: string[] = []){
+    const entityValues = {};
+    const tco: TypeClientOptions = await this.typeUtils.getEntityTypeClientOptionsUsingMapping(this.transformMapFile, this.mapFileUtil, data);
+    const type = await this.typeUtils.getByRootAndPath(tco);
+    const typePath = type['typePath'];
+    if(typePath && (typePath.startsWith('item') || typePath.startsWith('project-item'))){
+      if(['LCSProduct', 'LCSProductSeasonLink', 'LCSMaterial'].includes(objectClass)){
+        entityValues['roles'] = ['family'];
+      }else{
+        entityValues['roles'] = ['color', 'option'];
+      }
+    }
+
+    let typeProps = this.typeUtils.filterTypeProperties(type, entityValues);
+    typeProps = typeProps.filter( prop => !keysToSkip.includes(prop['slug']));
+
+    for(const prop of typeProps){
+      const slug = prop['slug'];
+      const value = await this.getEntityValue(prop, data);
+      if(value){
+        entityValues[slug] = value;
+      }
+    }
+
+    return entityValues;
+  }
+
+  /** Gets the VibeIQ value for the property from data
+   *
+   * @param prop the VibeIQ property
+   * @param data the FlexPLM data
+   * @returns value to be set in VibeIQ
+   */
+  async getEntityValue(prop, data) {
+    const propertyType = prop['propertyType'];
+    const slug = prop['slug'];
+    const nd = data[slug];
+    // this.logger.log('getValue: ' + propertyType + ', ' +slug + ', ' + nd);
+
+    let value;
+    if (['string', 'text'].includes(propertyType)) {
+      value = nd;
+    }else if(['number', 'currency', 'percent', 'sequence'].includes(propertyType)){
+      value = (null === nd)? 0 : nd;
+    }else if('date' === propertyType){
+      if(nd){
+        // const offset = new Date(nd).getTimezoneOffset() * 60 * 1_000;
+        // this.logger.log('nd: ' + nd);
+        // this.logger.log(offset);
+        // this.logger.log('No Offset: ' + new Date(nd).toISOString());
+        // const d = new Date(nd + offset);// Take system Timezone into account.
+        const d = new Date(nd);
+        value = d.toISOString();
+
+      } else {
+        value = null;
+      }
+    }else if('boolean' === propertyType){
+      value =(nd)? true: false;
+    }else if('choice' === propertyType){
+      value = this.setEnumerationKeys(prop, nd, this.useDisplayForEnumerationMatching);
+    }else if('multi_select' === propertyType){
+      value = this.setEnumerationKeys(prop, nd, this.useDisplayForEnumerationMatching);
+
+    } else if ('object_reference' === propertyType) {
+      value = await this.setObjectReferenceValue(prop, nd);
+    } else if ('image' === propertyType) {
+      // console.log('TODO-image');
+    } else if ('formula' === propertyType) {
+      // console.log('TODO-formula');
+    } else if ('json' === propertyType) {
+      // console.log('TODO-json');
+    } else if ('userList' === propertyType) {
+      value = await this.setUserListValue(prop, nd);
+    }else if ('size_range' === propertyType){
+      value = nd;
+    }
+
+    // console.log(value);
+    return value;
+  }
+
+  setEnumerationKeys(prop, nd, matchByDisplay) {
+    const propertyType = prop['propertyType'];
+    let value;
+    if(['choice', 'multi_select'].includes(propertyType)){
+      //If there are no options, use empty array to not error out and don't set anything
+      const options: [{value:string, display:string}] = prop['options'] || [];
+      if('choice' === propertyType){
+        if(nd){
+          const matchKey = (matchByDisplay)? 'display' : 'value';
+          const option = options.find(option => option[matchKey] == nd[matchKey] );
+          if(option){
+            value = option.value;
+          }
+        } else {
+          value = undefined;
+        }
+      }else if('multi_select' === propertyType){
+        value = [];
+        const matchKey = (matchByDisplay)? 'display' : 'value';
+        if(nd instanceof Array){
+          nd.forEach(selectedOpt =>{
+            const optionObject = options.find(option => option[matchKey] == selectedOpt[matchKey]);
+            if(optionObject){
+              const option = optionObject.value;
+              value.push(option);
+            }
+          });
+
+        }
+      }
+    }
+    return value;
+  }
+
+  /** Compares the potential changes to the entity and returns only the actual differences.
+   *
+   * @param entity the full entity
+   * @param changes the potential changes
+   * @returns only the change values that are different from the entity's value
+   */
+  getPersistableChanges(entity: object, changes: object): object {
+    const entityCompareValues = {};
+    for(const key of (Object.getOwnPropertyNames(changes))){
+      entityCompareValues[key] = entity[key];
+    }
+    const diffs: ObjectDiff[] = ObjectUtil.compareDeep(entityCompareValues, changes, '');
+    const diffValues = {};
+    if(diffs && diffs.length > 0){
+      for(const diff of diffs){
+        diffValues[diff.propertyName] = diff.newValue;
+      }
+    }
+    return diffValues;
+
+  }
+
+  /** Sets object reference value from FlexPLM data passed in
+   * 
+   * @param prop the VibeIQ property
+   * @param nd the VibeIQ data
+   * @returns the object reference id from VibeIQ
+   */
+  async setObjectReferenceValue(prop, nd) {
+    if (!nd) {
+      return "";
+    }
+
+    nd = await this.applyInboundTransformMap(nd);
+
+    const ctx = await this.buildObjectReferenceContext(prop, nd);
+    if (!ctx) {
+      return "";
+    }
+
+    if (this.objRefCache[ctx.cacheKey]) {
+      if (Logger.isDebugOn()) {
+        console.debug(`object reference cache hit: ${ctx.cacheKey}`);
+      }
+      return this.objRefCache[ctx.cacheKey];
+    }
+
+    const objectReferenceId = ctx.useIdentityService
+      ? await this.lookupObjectReferenceViaIdentityService(ctx, nd)
+      : await this.lookupObjectReferenceViaQuery(ctx);
+
+    if (objectReferenceId) {
+      this.objRefCache[ctx.cacheKey] = objectReferenceId;
+    }
+    return objectReferenceId;
+  }
+
+  private async applyInboundTransformMap(nd: any): Promise<any> {
+    if (!this.transformMapFile) {
+      return nd;
+    }
+    const mapKey = await TypeConversionUtils.getMapKeyFromObject(this.transformMapFile, this.mapFileUtil, nd, TypeConversionUtils.FLEX2VIBE_DIRECTION);
+    return MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, nd, mapKey as string, TypeConversionUtils.FLEX2VIBE_DIRECTION);
+  }
+
+  private async buildObjectReferenceContext(prop: any, nd: any): Promise<ObjectReferenceContext | null> {
+    const entityType = prop['referencedTypeRootSlug'];
+    const entityTypePath = prop['referencedTypePath'];
+    const entityKeys = Object.keys(nd);
+    const identifierKeys = await TypeConversionUtils.getIdentifierPropertiesFromObject(this.transformMapFile, this.mapFileUtil, nd);
+    const hasAllIdentifiers = identifierKeys.every(key => entityKeys.includes(key));
+    if (identifierKeys.length === 0 || !hasAllIdentifiers) {
+      console.warn(`The inbound ${entityType} for prop '${prop['slug']}' doesnt have all "identifier" properties, so there is no processing. Identifier properties: ${identifierKeys}`);
+      return null;
+    }
+
+    const rootType = await this.typeUtils.getByRootAndPath({root: entityType});
+    const rootTypeProps = this.typeUtils.filterTypeProperties(rootType, nd);
+
+    const rootTypeCriteria: Record<string, any> = {};
+    const typeCriteria: Record<string, any> = {};
+    identifierKeys.forEach(keyName => {
+      if (rootTypeProps.some(obj => obj.slug === keyName)) {
+        rootTypeCriteria[keyName] = nd[keyName];
+      } else {
+        typeCriteria[keyName] = nd[keyName];
+      }
+    });
+
+    const combinedCriteria = { ...rootTypeCriteria, ...typeCriteria, typePath: entityTypePath };
+    const cacheKey = Object.values(combinedCriteria).join('_');
+    const rolesIsTypeDiscriminator = entityType === 'item' || entityType === 'project-item';
+    const identityLookupKeys = rolesIsTypeDiscriminator
+      ? identifierKeys.filter(key => key !== 'roles')
+      : identifierKeys;
+    const useIdentityService = ConfigDefaults.isPropertyTrue(this.config?.search?.[entityType]?.useIdentityServiceForInboundData)
+      && identityLookupKeys.length === 1;
+
+    return { entityType, entityTypePath, rootTypeCriteria, typeCriteria, combinedCriteria, cacheKey, useIdentityService, identityLookupKeys };
+  }
+
+  private async lookupObjectReferenceViaIdentityService(ctx: ObjectReferenceContext, nd: any): Promise<string> {
+    const propertyName = ctx.identityLookupKeys[0];
+    const propertyValue = nd[propertyName];
+    const poolKey = await TypeConversionUtils.getUniquenessPoolKeyFromObject(this.transformMapFile, this.mapFileUtil, nd);
+
+    const identityResults = await new Entities().get({
+      entityName: 'identity',
+      criteria: { poolKey, propertyName, propertyValue }
+    }) ?? [];
+
+    const match = this.pickSingleResult(identityResults, ctx.combinedCriteria);
+    return match ? match.entityReference.split(':')[1] : "";
+  }
+
+  private async lookupObjectReferenceViaQuery(ctx: ObjectReferenceContext): Promise<string> {
+    let arrObjectReferences = await this.getAllObjectReferences(ctx.entityType, ctx.rootTypeCriteria);
+    if (ctx.entityType !== ctx.entityTypePath) {
+      arrObjectReferences = this.checkKeysAndValues(ctx.typeCriteria, arrObjectReferences, ctx.entityTypePath);
+    }
+    const match = this.pickSingleResult(arrObjectReferences, ctx.combinedCriteria);
+    return match ? match.id : "";
+  }
+
+  private pickSingleResult(results: any[], combinedCriteria: any): any | undefined {
+    if (!results.length) {
+      console.warn(`The passed in object reference criteria ${JSON.stringify(combinedCriteria)} didn't match any entities.`);
+      return undefined;
+    }
+    if (results.length > 1) {
+      console.warn(`The passed in object reference criteria has duplicate records found ${JSON.stringify(combinedCriteria)}.`);
+      return undefined;
+    }
+    return results[0];
+  }
+
+  /**
+   * Retrieves all object references of a specified entity type based on the provided criteria.
+   * This function handles pagination and asynchronously fetches object references until there are no more pages.
+   * @param {string} entityType - The type of entity for which object references are to be retrieved.
+   * @param {object} rootTypeCriteria - The criteria used to filter object references.
+   * @returns {Promise<Array>} A Promise that resolves to an array containing all object references.
+   */
+  async getAllObjectReferences(entityType: string, rootTypeCriteria, postProcessCriteria = null) {
+    const entities = new Entities();
+    let loads = [];
+    let nextPageKey;
+    let usedV2 = false;
+    do {
+      const take = 1000;
+      const loadPage = await entities.get({
+        entityName: entityType,
+        criteria: rootTypeCriteria,
+        apiVersion: API_VERSION.V2,
+        take,
+        nextPageKey,
+      });
+      nextPageKey = loadPage?.nextPageKey;
+      if (Object.keys(loadPage).includes('results')) {
+        usedV2 = true;
+        let postProcessedResults = this.filterOutArchivedAndTrashedEntities(loadPage?.results);
+        if(postProcessedResults?.length > 0 && postProcessCriteria && Object.keys(postProcessCriteria).length !== 0) {
+          const subEntityTypePath = rootTypeCriteria.typePath || entityType;
+          postProcessedResults = this.checkKeysAndValues(postProcessCriteria, postProcessedResults, subEntityTypePath);
+        }
+        loads.push(...postProcessedResults);
+      } else {
+        nextPageKey = null;
+      }
+    } while (nextPageKey);
+
+    if (!usedV2) {
+      const take = 1000;
+      let skip = 0;
+      let done = false;
+      while (!done) {
+        const loadPage = await entities.get({
+          entityName: entityType,
+          criteria: rootTypeCriteria,
+          take,
+          skip,
+        });
+        let postProcessedResults = this.filterOutArchivedAndTrashedEntities(loadPage);
+        if(postProcessCriteria && Object.keys(postProcessCriteria).length !== 0) {
+          const subEntityTypePath = rootTypeCriteria.typePath || entityType;
+          postProcessedResults = this.checkKeysAndValues(postProcessCriteria, postProcessedResults, subEntityTypePath);
+        }
+        loads.push(...postProcessedResults);
+
+        if (loadPage.length !== take) {
+          done = true;
+        } else {
+          skip += take;
+        }
+      }
+    }
+
+    return loads;
+  }
+  
+  /**
+   * Checks if all keys and values of a given object are present in an array of objects.
+   * @param {Object} criteria - The object whose keys and values are to be checked in the array of objects.
+   * @param {Array<Object>} arrayOfObjects - The array of objects to be searched for matching keys and values.
+   * @param {string} entityTypePath - The type / subtype for the property; objects must be this type or a sub type of it.
+   * @returns {(Object|boolean)} Returns the array of objects that matches all keys and values of the provided object.
+   *                             If no match is found, returns empty array.
+   */
+  checkKeysAndValues(criteria, arrayOfObjects, entityTypePath) {
+    let arrOfMatchObjects = [];
+    for (let i = 0; i < arrayOfObjects.length; i++) {
+      const currentObj = arrayOfObjects[i];
+      let found = true;
+  
+      if(entityTypePath && currentObj['typePath']){
+        const currentObjPath = '' + currentObj['typePath'];
+        if(!currentObjPath.startsWith(entityTypePath)){
+          found = false;
+        }
+      }
+      for (const key in criteria) {
+        if (!(key in currentObj) || currentObj[key] !== criteria[key]) {
+          found = false;
+          break;
+        }
+      }
+  
+      if (found) {
+        arrOfMatchObjects.push(currentObj);
+      }
+    }
+
+    return arrOfMatchObjects;
+  }
+
+  /** Filters out archived and trashed entities from the provided array of entities.
+   *
+   * @param entities
+   * @returns
+   */
+
+  filterOutArchivedAndTrashedEntities(entities: any[]) {
+    if(!entities || !Array.isArray(entities) || entities.length === 0){
+      return [];
+    }
+    return entities.filter(entity => {
+      const isArchived = entity?.isArchived;
+      const isTrashed = entity?.isTrashed;
+      return !isArchived && !isTrashed;
+    });
+  }
+
+  /** Sets userListId value from FlexPLM data passed in
+   * 
+   * @param prop the VibeIQ property
+   * @param nd the VibeIQ data
+   * @returns the modified entity with FlexPLM values
+   */
+  async setUserListValue(prop, nd) {
+    if(!nd?.email) {
+        return "";
+    }    
+    let cacheUser = DataConverter.getFromStaticCache(nd.email);
+    if (cacheUser) {
+        if (Logger.isDebugOn()) {
+            console.debug('user cache hit: ' + nd.email);
+        }
+
+        await this.processGroupMemberCheck(prop, nd.email);
+        return cacheUser;
+    }
+
+    const user = await this.getUserByEmail(nd);
+    const userId = (user)?user.id:undefined;
+
+    if(userId) {
+      DataConverter.setToStaticCache(nd.email, userId);
+      await this.processGroupMemberCheck(prop, nd.email);
+    }
+
+    return userId;
+  }
+
+  /** Makes batch calls of 1000 of user-org entities until
+   * it find one with userEmail of passed in nd.email.
+   * Maxes out after querying for 15,000 user-org entities
+   *
+   * @param nd
+   * @returns
+   */
+  async getUserByEmail(nd: any) {
+    let userOrg = undefined;
+    let count =0;
+    let size = 0;
+    let emailInput = nd?.email.toLowerCase();
+
+    const entities = new Entities();
+    const getOptionsCriteria = {
+      entityName: 'user-org',
+      take:1000
+    }
+
+    do {
+      const userBatch: [any] = await entities.get(getOptionsCriteria);
+      userOrg = userBatch.find(uo => uo?.userEmail.toLowerCase() === emailInput);
+
+    }while( !userOrg && size == getOptionsCriteria.take && count < 15);
+    return userOrg?.user
+
+  }
+
+  /** Shows warning if user email address not present in group associated to property
+   *
+   * @param prop the VibeIQ property
+   * @param userEmail user email address
+   */
+  async processGroupMemberCheck(prop, userEmail) {
+    let arrUserList = [];
+    if(this.userRefCache[prop.typePropertyUserListId]) {
+      arrUserList = this.userRefCache[prop.typePropertyUserListId];
+    } else {
+      const userListResult = await new Entities().get({
+        entityName: 'user-list',
+        id: prop.typePropertyUserListId
+      });
+
+      if(userListResult && Object.keys(userListResult).length) {
+        arrUserList = userListResult.userList;
+        this.userRefCache[prop.typePropertyUserListId] = arrUserList;
+      }
+    }
+
+    if(arrUserList.length) {
+      const result = arrUserList.find(element => element['display'] === userEmail);
+      if(!result) {
+          console.warn(`The passed in user ${userEmail} in property slug ${prop.slug} should be a member of the group associated with the property 'typePropertyUserListId'`)
+      }
+    }
+  }
+
+  /** Gets the VibeIQ value for the userList property from data
+   *
+   * @param prop the VibeIQ property
+   * @param newData the FlexPLM data
+   * @returns value to be set in VibeIQ
+   */
+  async getUserListValue(prop, newData) {
+      const slug = prop['slug'];
+      if (Logger.isDebugOn()) {
+          console.debug('getUserListValue-prop: ' + slug);
+      }
+
+      const entityId = newData[slug + 'Id'];
+
+      if(!entityId) {
+          return {};
+      }
+
+      const cacheUser = DataConverter.getFromStaticCache(entityId);
+      if (cacheUser) {
+          if (Logger.isDebugOn()) {
+              console.debug('user cache hit: ' + entityId);
+          }
+          return Object.assign({}, cacheUser);
+      }
+
+      const user = await this.getUserById(entityId);
+
+      const value = (user) ? {
+          email: user.email,
+          firstName: user.first,
+          lastName: user.last,
+          isSsoUser: user.isSsoUser,
+      } : undefined;
+
+      if(value) {
+          DataConverter.setToStaticCache(entityId, value);
+      }
+
+      return value;
+  }
+
+  /** Makes batch calls of 1000 of user-org entities until
+   * it find one with user.id of passed in userId.
+   * Maxes out after querying for 15,000 user-org entities
+   *
+   * @param userId
+   * @returns
+   */
+  async getUserById(userId: any) {
+    let userOrg = undefined;
+    let count =0;
+    let size = 0;
+    const entities = new Entities();
+    const getOptionsCriteria = {
+      entityName: 'user-org',
+      take:1000
+    }
+
+    do {
+      const userBatch: [any] = await entities.get(getOptionsCriteria);
+      userOrg = userBatch.find(uo => uo?.user?.id === userId);
+
+    }while( !userOrg && size == getOptionsCriteria.take && count < 15);
+    return userOrg?.user
+  }
+
+}