@contrail/flexplm 1.4.0 → 1.5.0-alpha.0d65410

package/src/util/data-converter.ts

@@ -6,6 +6,18 @@ 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;
@@ -287,7 +299,7 @@ export class DataConverter {
     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)){
+      if(['LCSProduct', 'LCSProductSeasonLink', 'LCSMaterial'].includes(objectClass)){
         entityValues['roles'] = ['family'];
       }else{
         entityValues['roles'] = ['color', 'option'];
@@ -426,33 +438,60 @@ export class DataConverter {
    * @returns the object reference id from VibeIQ
    */
   async setObjectReferenceValue(prop, nd) {
-    let objectReferenceId = "";
-    if(!nd) {
-      return objectReferenceId;
+    if (!nd) {
+      return "";
     }
-    if(this.transformMapFile){
-      const mapKey = await TypeConversionUtils.getMapKeyFromObject(this.transformMapFile, this.mapFileUtil, nd, TypeConversionUtils.FLEX2VIBE_DIRECTION);
-      nd = await MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, nd, mapKey, TypeConversionUtils.FLEX2VIBE_DIRECTION)
+
+    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 identifierKeys = await TypeConversionUtils.getIdentifierPropertiesFromObject(this.transformMapFile, this.mapFileUtil, nd);
     const hasAllIdentifiers = identifierKeys.every(key => entityKeys.includes(key));
-    if(identifierKeys.length == 0 || !hasAllIdentifiers){
+    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 objectReferenceId;
+      return null;
     }
-    
+
     const rootType = await this.typeUtils.getByRootAndPath({root: entityType});
     const rootTypeProps = this.typeUtils.filterTypeProperties(rootType, nd);
 
-    let rootTypeCriteria = {};
-    let typeCriteria = { };
+    const rootTypeCriteria: Record<string, any> = {};
+    const typeCriteria: Record<string, any> = {};
     identifierKeys.forEach(keyName => {
-      const foundInObjects = rootTypeProps.some(obj => obj.slug === keyName);
-      if (foundInObjects) {
+      if (rootTypeProps.some(obj => obj.slug === keyName)) {
         rootTypeCriteria[keyName] = nd[keyName];
       } else {
         typeCriteria[keyName] = nd[keyName];
@@ -461,35 +500,49 @@ export class DataConverter {
 
     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 };
+  }
 
-    if (this.objRefCache[cacheKey]) {
-      if (Logger.isDebugOn()) {
-        console.debug(`object reference cache hit: ${cacheKey}`);
-      }
-      return this.objRefCache[cacheKey];
-    }
+  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);
 
-    let arrObjectReferences = await this.getAllObjectReferences(entityType, rootTypeCriteria);
-    if(entityType !== entityTypePath) {
-      arrObjectReferences = this.checkKeysAndValues(typeCriteria, arrObjectReferences, entityTypePath);
-    }
+    const identityResults = await new Entities().get({
+      entityName: 'identity',
+      criteria: { poolKey, propertyName, propertyValue }
+    }) ?? [];
 
-    if(arrObjectReferences.length) {
-      if(arrObjectReferences.length === 1) {
-        objectReferenceId = arrObjectReferences[0].id;
-      } else {
-        console.warn(`The passed in object reference criteria has duplicate records found ${JSON.stringify(combinedCriteria)}.`);
-      }
+    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 : "";
+  }
 
-    if (!objectReferenceId) {
+  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 objectReferenceId;
+      return undefined;
     }
-
-    this.objRefCache[cacheKey] = objectReferenceId;
-
-    return objectReferenceId;
+    if (results.length > 1) {
+      console.warn(`The passed in object reference criteria has duplicate records found ${JSON.stringify(combinedCriteria)}.`);
+      return undefined;
+    }
+    return results[0];
   }
 
   /**

package/src/util/type-defaults.spec.ts

@@ -485,6 +485,30 @@ describe('Type Defaults', () =>{
       expect(entityClass).toBe('custom-entity');
     });
 
+    it('item - LCSMaterial - processAsItem=true', () =>{
+      const object = {
+        flexPLMObjectClass: 'LCSMaterial'
+      };
+
+      TypeDefaults.applyConfig({ LCSMaterial: { processAsItem: true } });
+      try {
+        const entityClass = TypeDefaults.getDefaultEntityClass(object);
+        expect(entityClass).toBe('item');
+      } finally {
+        TypeDefaults.applyConfig({});
+      }
+    });
+
+    it('custom-entity - LCSMaterial - processAsItem=false (default)', () =>{
+      const object = {
+        flexPLMObjectClass: 'LCSMaterial'
+      };
+
+      const entityClass = TypeDefaults.getDefaultEntityClass(object);
+
+      expect(entityClass).toBe('custom-entity');
+    });
+
   });//getDefaultEntityClass
 
   describe('getDefaultEntityTypePath', () =>{
@@ -549,6 +573,28 @@ describe('Type Defaults', () =>{
       const typePath = TypeDefaults.getDefaultEntityTypePath(object);
       expect(typePath).toBe('assortment');
     });
+
+    it('LCSMaterial - processAsItem=true', () =>{
+      const object = {
+        flexPLMObjectClass: 'LCSMaterial'
+      };
+
+      TypeDefaults.applyConfig({ LCSMaterial: { processAsItem: true } });
+      try {
+        const typePath = TypeDefaults.getDefaultEntityTypePath(object);
+        expect(typePath).toBe('item:material');
+      } finally {
+        TypeDefaults.applyConfig({});
+      }
+    });
+
+    it('LCSMaterial - processAsItem=false (default) throws', () =>{
+      const object = {
+        flexPLMObjectClass: 'LCSMaterial'
+      };
+
+      expect(() => TypeDefaults.getDefaultEntityTypePath(object)).toThrowError(TypeDefaults.NO_TYPE_PATH);
+    });
   });//getDefaultEntityTypePath
 
   describe('getDefaultIdentifierPropertiesFromObject', () =>{
@@ -622,6 +668,30 @@ describe('Type Defaults', () =>{
       expect(defaultIdentifiers).toHaveLength(1);
     });
 
+    it('LCSMaterial - processAsItem=true', () =>{
+      const object = {
+        flexPLMObjectClass: 'LCSMaterial'
+      };
+      TypeDefaults.applyConfig({ LCSMaterial: { processAsItem: true } });
+      try {
+        const defaultIdentifiers = TypeDefaults.getDefaultIdentifierPropertiesFromObject(object);
+        expect(defaultIdentifiers).toContain('itemNumber');
+        expect(defaultIdentifiers).toHaveLength(1);
+      } finally {
+        TypeDefaults.applyConfig({});
+      }
+    });
+
+    it('LCSMaterial - processAsItem=false (default)', () =>{
+      const object = {
+        flexPLMObjectClass: 'LCSMaterial'
+      };
+      const defaultIdentifiers = TypeDefaults.getDefaultIdentifierPropertiesFromObject(object);
+
+      expect(defaultIdentifiers).toContain('name');
+      expect(defaultIdentifiers).toHaveLength(1);
+    });
+
   });//getDefaultIdentifierPropertiesFromObject
 
   describe('getDefaultInformationalPropertiesFromObject', () =>{
@@ -665,5 +735,63 @@ describe('Type Defaults', () =>{
       expect(defaultIdentifiers).toHaveLength(1);
     });
 
+    it('LCSMaterial - processAsItem=true', () =>{
+      const object = {
+        flexPLMObjectClass: 'LCSMaterial'
+      };
+
+      TypeDefaults.applyConfig({ LCSMaterial: { processAsItem: true } });
+      try {
+        const defaultIdentifiers = TypeDefaults.getDefaultInformationalPropertiesFromObject(object);
+        expect(defaultIdentifiers).toContain('name');
+        expect(defaultIdentifiers).toHaveLength(1);
+      } finally {
+        TypeDefaults.applyConfig({});
+      }
+    });
+
+    it('LCSMaterial - processAsItem=false (default) yields no informational props', () =>{
+      const object = {
+        flexPLMObjectClass: 'LCSMaterial'
+      };
+
+      const defaultIdentifiers = TypeDefaults.getDefaultInformationalPropertiesFromObject(object);
+      expect(defaultIdentifiers).toHaveLength(0);
+    });
+
   });//getDefaultInformationalPropertiesFromObject
+
+  describe('applyConfig', () => {
+    afterEach(() => {
+      TypeDefaults.applyConfig({});
+    });
+
+    it('sets processLCSMaterialAsItem=true when processAsItem=true', () => {
+      TypeDefaults.applyConfig({ LCSMaterial: { processAsItem: true } });
+      expect(TypeDefaults.processLCSMaterialAsItem).toBe(true);
+    });
+
+    it('sets processLCSMaterialAsItem=true when processAsItem=\"true\" (string)', () => {
+      TypeDefaults.applyConfig({ LCSMaterial: { processAsItem: 'true' } });
+      expect(TypeDefaults.processLCSMaterialAsItem).toBe(true);
+    });
+
+    it('sets processLCSMaterialAsItem=false when processAsItem=false', () => {
+      TypeDefaults.processLCSMaterialAsItem = true;
+      TypeDefaults.applyConfig({ LCSMaterial: { processAsItem: false } });
+      expect(TypeDefaults.processLCSMaterialAsItem).toBe(false);
+    });
+
+    it('sets processLCSMaterialAsItem=false when LCSMaterial missing', () => {
+      TypeDefaults.processLCSMaterialAsItem = true;
+      TypeDefaults.applyConfig({});
+      expect(TypeDefaults.processLCSMaterialAsItem).toBe(false);
+    });
+
+    it('sets processLCSMaterialAsItem=false when config is null/undefined', () => {
+      TypeDefaults.processLCSMaterialAsItem = true;
+      TypeDefaults.applyConfig(undefined);
+      expect(TypeDefaults.processLCSMaterialAsItem).toBe(false);
+    });
+  });
 });

package/src/util/type-defaults.ts

@@ -2,8 +2,25 @@ export class TypeDefaults {
   static NO_ENTITY_TYPE = 'Not able to determine the entity type of the entity object';
   static NO_OBJECT_CLASS = 'Please ensure that the flexPLMObjectClass property is provided.';
   static NO_TYPE_PATH = 'Please ensure that the flexPLMTypePath property is provided.';
+  static processLCSMaterialAsItem = false;
   constructor() {
   }
+
+  /** Applies values from the resolved config to TypeDefaults static state.
+   *  Currently toggles whether LCSMaterial is treated as an item (new) or a
+   *  custom-entity (old) based on config.LCSMaterial.processAsItem.
+   *  Technically this could cause side effects if different parts of the code
+   *  expect different behavior, but in practice * @param config will be 
+   *  consistent across the app and this is simpler than passing this config
+   *  through multiple layers of function calls.
+   */
+  static applyConfig(config: any): void {
+    TypeDefaults.processLCSMaterialAsItem = TypeDefaults.isPropertyTrue(config?.LCSMaterial?.processAsItem);
+  }
+
+  static isPropertyTrue(value: any): boolean {
+    return value === true || (typeof value === 'string' && value.toLowerCase() === 'true');
+  }
   /**Takes in full entity and returs the default FlexPLM
    * object class.
    *
@@ -87,7 +104,7 @@ export class TypeDefaults {
    */
 
   static getDefaultIdentifierProperties(entity): string[] {
-    const identifierProps = [];
+    const identifierProps: string[] = [];
     const entityType = this.getEntityType(entity);
 
     switch (entityType) {
@@ -168,7 +185,14 @@ export class TypeDefaults {
   static getDefaultEntityClass(object): string {
     let entityClass = '';
     let objectClass = TypeDefaults.getObjectClass(object);
-    if(['LCSProduct', 'LCSSKU'].includes(objectClass)){
+    const itemClasses = TypeDefaults.processLCSMaterialAsItem
+      ? ['LCSProduct', 'LCSSKU', 'LCSMaterial']
+      : ['LCSProduct', 'LCSSKU'];
+    const customEntityClasses = TypeDefaults.processLCSMaterialAsItem
+      ? ['LCSRevisableEntity', 'LCSLifecycleManaged', 'LCSLast']
+      : ['LCSRevisableEntity', 'LCSLifecycleManaged', 'LCSLast', 'LCSMaterial'];
+
+    if(itemClasses.includes(objectClass)){
       entityClass = 'item';
     }else if(['LCSProductSeasonLink', 'LCSSKUSeasonLink'].includes(objectClass)){
       entityClass = 'project-item'
@@ -176,7 +200,7 @@ export class TypeDefaults {
       entityClass = 'color';
     } else if(['LCSSeason', 'SeasonGroup'].includes(objectClass)) {
       entityClass = 'assortment';
-    } else if(['LCSRevisableEntity', 'LCSLifecycleManaged', 'LCSLast', 'LCSMaterial'].includes(objectClass)) {
+    } else if(customEntityClasses.includes(objectClass)) {
       entityClass = 'custom-entity';
     }
 
@@ -201,6 +225,11 @@ export class TypeDefaults {
         case 'LCSSKU':
           typePath = 'item';
           break;
+        case 'LCSMaterial':
+          if (TypeDefaults.processLCSMaterialAsItem) {
+            typePath = 'item:material';
+          }
+          break;
         case 'LCSProductSeasonLink':
         case 'LCSSKUSeasonLink':
           typePath = 'project-item';
@@ -229,7 +258,7 @@ export class TypeDefaults {
    */
 
   static getDefaultIdentifierPropertiesFromObject(object): string[] {
-    const identifierProps = [];
+    const identifierProps: string[] = [];
     const objectClass = TypeDefaults.getObjectClass(object);
 
     switch (objectClass) {
@@ -237,6 +266,13 @@ export class TypeDefaults {
       case 'LCSSKU':
           identifierProps.push('itemNumber');
         break;
+      case 'LCSMaterial':
+        if (TypeDefaults.processLCSMaterialAsItem) {
+          identifierProps.push('itemNumber');
+        } else {
+          identifierProps.push('name');
+        }
+        break;
       case 'LCSSeason':
         identifierProps.push('flexPLMSeasonName');
         break;
@@ -247,7 +283,6 @@ export class TypeDefaults {
       case 'LCSRevisableEntity':
       case 'LCSLifecycleManaged':
       case 'LCSLast':
-      case 'LCSMaterial':
         identifierProps.push('name');
         break;
     }
@@ -265,7 +300,11 @@ export class TypeDefaults {
     static getDefaultInformationalPropertiesFromObject(object): string[] {
       const objectClass = TypeDefaults.getObjectClass(object);
       let properties:string[] = [];
-      if ('LCSProduct' === objectClass) {
+      const itemClasses = TypeDefaults.processLCSMaterialAsItem
+        ? ['LCSProduct', 'LCSMaterial']
+        : ['LCSProduct'];
+
+      if (itemClasses.includes(objectClass)) {
         properties.push('name');
       } else if ('LCSSKU' === objectClass) {
         properties.push('optionName');