@contrail/flexplm 1.1.13 → 1.1.15

package/src/util/data-converter.ts

@@ -0,0 +1,507 @@
+import { 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';
+
+export class DataConverter {
+  private typeUtils: TypeUtils;
+  private transformMapFile: string;
+  private useDisplayForEnumerationMatching = false;
+  private objRefCache = {};
+  private userRefCache = {};
+  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'];
+  }
+
+  async getFlexPLMObjectDataFromEvent(event, dataToSkip: string[]) {
+    return this.getFlexPLMObjectData(event.newData, dataToSkip, true);
+  }
+
+  async getFlexPLMObjectData(newData, dataToSkip: string[], inflateObjRef: boolean) {
+    if(Logger.isDebugOn()) {
+      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(Logger.isDebugOn()) {
+      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(Logger.isDebugOn()){
+        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);
+    }
+
+    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', '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') {
+          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 = this.typeUtils.getEntityTypeClientOptions(objectClass,data);
+    const type = await this.typeUtils.getByRootAndPath(tco);
+    const typePath = type['typePath'];
+    if(typePath && (typePath.startsWith('item') || typePath.startsWith('project-item'))){
+      if(['LCSProduct', 'LCSProductSeasonLink'].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) {
+      //TODO write code
+      //use referencedTypeRootSlug to get the entity type
+    } 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);
+    }
+
+    // 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 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 "";
+    }    
+
+    if (this.userRefCache[nd.email]) {
+        if (Logger.isDebugOn()) {
+            console.debug('user cache hit: ' + nd.email);
+        }
+
+        await this.processGroupMemberCheck(prop, nd.email);
+        return this.userRefCache[nd.email];
+    }
+
+    const entities = await new Entities().get({
+        entityName: 'user-org',
+        take: 1000
+    });
+
+    const result = entities.find(element => element['userEmail'] === nd.email);
+    const value = (result) ? result.id : undefined;
+
+    if(value) {
+      this.userRefCache[nd.email] = value;
+      await this.processGroupMemberCheck(prop, nd.email);
+    }
+
+    return value;
+  }
+
+  /** 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 {};
+      }
+
+      if (this.userRefCache[entityId]) {
+          if (Logger.isDebugOn()) {
+              console.debug('user cache hit: ' + entityId);
+          }
+          return this.userRefCache[entityId];
+      }
+
+      const entities = await new Entities().get({
+          entityName: 'user-org',
+          id: entityId
+      });
+
+      const value = (entities) ? {
+          email: entities.userEmail, 
+          firstName: entities.first, 
+          lastName: entities.last,
+          isSsoUser: entities.isSsoUser,
+      } : undefined;
+
+      if(value) {
+          this.userRefCache[entityId] = value;
+      }
+
+      return value;
+  }
+
+}

package/src/util/federation.ts

@@ -0,0 +1,172 @@
+import { Entities } from '@contrail/sdk';
+
+import { FederationRecord } from '../interfaces/interfaces';
+import pLimit from 'p-limit';
+const limit = pLimit(30);
+
+interface fedConfigDef {
+  appIdentifier: string,
+  federationSchema: string
+}
+const FED_CONFIG: fedConfigDef = {
+  appIdentifier: '@vibeiq/flexplm-connector',
+  federationSchema: 'DEFAULT'
+};
+export class Federation {
+
+  private CHUNK_SIZE = 50;
+
+  async getFederatedMappedRefId(entityType: string, entityId: string) {
+    const criteria = {
+      reference: entityType + ':' + entityId,
+      appIdentifier: FED_CONFIG.appIdentifier,
+      federationSchema: FED_CONFIG.federationSchema
+    };
+    console.log('getFederatedMappedRefId: ' + JSON.stringify(criteria));
+    const fedRecords: FederationRecord[] = await new Entities().get({
+      entityName: 'federation',
+      criteria
+    });
+
+    const federatedId = (fedRecords[0])
+      ? fedRecords[0]['mappedReference']
+      : '';
+
+    return federatedId;
+  }
+
+  async createFederatedRecord(eventBody) {
+    const itemResults = eventBody.payload;
+    for (let i = 0; i < itemResults.length; i++) {
+      if (!itemResults[i].federatedId) {
+        continue;
+      }
+      const payload: FederationRecord = {
+        appIdentifier: FED_CONFIG.appIdentifier,
+        reference: itemResults[i].entityReference,
+        mappedReference: itemResults[i].federatedId,
+        federationSchema: FED_CONFIG.federationSchema
+      };
+      // console.log('createFederatedRecord: ' + JSON.stringify(payload));
+
+      try {
+        const results = await new Entities().create({ entityName: 'federation', object: payload });
+        return results;
+        // console.log(JSON.stringify(results));
+      } catch (error) {
+        console.log('createFederatedRecord-error: ', error);
+        throw new Error('Error creating federation record: ' + error.message);
+      }
+    }
+  }
+
+  async getFederationRecordFromMappedRefId(mappedRefId: string) {
+    const criteria = {
+      appIdentifier: FED_CONFIG.appIdentifier,
+      mappedReference: mappedRefId,
+      federationSchema: FED_CONFIG.federationSchema
+    };
+    try {
+      const fedRecords: FederationRecord[] = await new Entities().get({
+        entityName: 'federation',
+        criteria
+      });
+      return (fedRecords && fedRecords[0]) ? fedRecords[0] : undefined;
+    } catch (e) {
+      console.log('getFederationData-error: ' + e.message);
+    }
+    return undefined;
+  }
+
+  static getEntityId(fedRecord: FederationRecord) {
+    const entityString = fedRecord['reference'];
+    const entitySplit = entityString.split(':');
+    const entityType = entitySplit[0];
+    const entityId = entitySplit[1];
+
+    return { entityType, entityId };
+
+  }
+
+  async getEntityFromMappedRefId(mappedRefId: string) {
+    // console.log('!---getEntityFromMappedRefId: ' + mappedRefId);
+    const fedRecord = await this.getFederationRecordFromMappedRefId(mappedRefId);
+    console.log('fedRecord: ' + JSON.stringify(fedRecord));
+    if (!fedRecord) {
+      //Not creating from FlexPLM at this time.
+      console.log('Federation Record doesnt exist. Cant get entity!');
+      return;
+    }
+
+    const { entityType, entityId } = Federation.getEntityId(fedRecord);
+    // console.log(entityType + ':' + entityId);
+    const criteria = {
+      id: entityId
+    };
+    const entities = await new Entities().get({
+      entityName: entityType,
+      criteria
+    });
+    const entity = (entities && entities[0]) ? entities[0] : undefined;
+    // console.log(' entities: ' +JSON.stringify(entities));
+    return entity;
+  }
+
+  async getFederationRecordsFromIds(ids: string[]): Promise<FederationRecord[]> {
+    const fedRecords = [];
+    for (let i = 0; i < ids.length; i++) {
+      const criteria = {
+        reference: ids[i],
+        appIdentifier: FED_CONFIG.appIdentifier,
+        federationSchema: FED_CONFIG.federationSchema
+      };
+      // this.logger.log('getFederatedMappedRefId: ' + JSON.stringify(criteria));
+      const recs: FederationRecord[] = await new Entities().get({
+        entityName: 'federation',
+        criteria
+      });
+      if (recs[0]) {
+        fedRecords.push(recs[0]);
+      }
+    }
+
+    return fedRecords;
+  }
+
+  async getFederationRecordsFromIdsBulk(ids: string[]): Promise<FederationRecord[]> {
+
+    const chunks: string[][] = this.splitIntoChunksByLen(ids, this.CHUNK_SIZE);
+    const fedRecords = [];
+    const federatedPromises = [];
+    const entities: Entities = new Entities();
+    for (const chunk of chunks) {
+      const fedPromise = limit(async () => {
+        const criteria = {
+          references: chunk,
+          appIdentifier: FED_CONFIG.appIdentifier,
+          federationSchema: FED_CONFIG.federationSchema
+        };
+        // this.logger.log('getFederatedMappedRefId: ' + JSON.stringify(criteria));
+        const records: FederationRecord[] = await entities.get({
+          entityName: 'federation',
+          criteria
+        });
+        fedRecords.push(...records);
+
+      });
+      federatedPromises.push(fedPromise);
+    }
+    await Promise.all(federatedPromises);
+
+    return fedRecords;
+  }
+
+  splitIntoChunksByLen(arr, len) {
+    const chunks = [], n = arr?.length;
+    let i = 0;
+    while (i < n) {
+      chunks.push(arr.slice(i, i += len));
+    }
+    return chunks;
+  }
+}