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

package/src/util/type-defaults.ts

@@ -0,0 +1,320 @@
+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.
+   *
+   * @param entity
+   * @returns string
+   */
+  static getDefaultObjectClass(entity): string {
+    const entityType = this.getEntityType(entity);
+    let objectClass = '';
+    if ('item' === entityType) {
+      if (entity.roles.includes('family')) {
+        objectClass = 'LCSProduct';
+      } else if (entity.roles.includes('color')) {
+        objectClass = 'LCSSKU';
+      }
+    } else if ('project-item' === entityType) {
+      if (entity.roles.includes('family')) {
+        objectClass = 'LCSProductSeasonLink';
+      } else if (entity.roles.includes('color')) {
+        objectClass = 'LCSSKUSeasonLink';
+      }
+    } else if ('color' === entityType) {
+      objectClass = 'LCSColor';
+    } else if ('custom-entity' === entityType) {
+      objectClass = 'LCSRevisableEntity';
+    } else if ('project' === entityType) {
+      objectClass = 'LCSSeason';
+    } else if ('assortment' === entityType) {
+      if('LCSSeason' === entity.flex2vibeMapKeyRoot || entity.publishToFlexPLM){
+        objectClass = 'LCSSeason';
+      }else{
+        objectClass = 'SeasonGroup';
+      }
+    }
+    return objectClass;
+
+  }
+
+  /**Takes in full entity and returns the default FlexPLM type path
+   * object class.
+   *
+   * @param entity
+   * @returns string
+   */
+  static getDefaultObjectTypePath(entity): string {
+    let typePath = '';
+    const entityType = this.getEntityType(entity);
+
+    switch (entityType) {
+      case 'item':
+      case 'project-item':
+        typePath = 'Product';
+        break;
+      case 'color':
+        typePath = 'Color';
+        break;
+      case 'custom-entity':
+        typePath = 'Revisable Entity';
+        break;
+      case 'project':
+        typePath = 'Season';
+        break;
+      case 'assortment':
+        if('LCSSeason' === entity.flex2vibeMapKeyRoot || entity.publishToFlexPLM){
+          typePath = 'Season';
+        }else{
+          typePath = 'Season Group';
+        }
+        break;
+    }
+
+    return typePath;
+  }
+
+  /**Takes in full entity and returns the slugs for the default identifier
+   *  properties. These properties are used when searching for an entity
+   * object class.
+   *
+   * @param entity
+   * @returns string[]
+   */
+
+  static getDefaultIdentifierProperties(entity): string[] {
+    const identifierProps: string[] = [];
+    const entityType = this.getEntityType(entity);
+
+    switch (entityType) {
+      case 'item':
+        identifierProps.push('itemNumber');
+        break;
+      case 'project':
+        identifierProps.push('flexPLMSeasonName');
+        break;
+      case 'assortment':
+        if('LCSSeason' === entity.flex2vibeMapKeyRoot ||entity.publishToFlexPLM){
+          identifierProps.push('flexPLMSeasonName');
+        }else{
+          identifierProps.push('seasonGroupName');
+        }
+        break;
+      case 'color':
+      case 'custom-entity':
+        identifierProps.push('name');
+        break;
+    }
+
+    return identifierProps;
+  }
+
+  /** Takes in full entity and returns the slugs for informational
+   * properties.  These properties are helpful when debugging issues
+   * where the identifier properties don't find a match.
+   * 
+   * @param entity 
+   * @returns string[]
+   */
+  static getDefaultInformationalProperties(entity): string[] {
+    const entityType = this.getEntityType(entity);
+    let properties:string[] = [];
+    if ('item' === entityType) {
+      if (entity.roles.includes('family')) {
+        properties.push('name');
+      } else if (entity.roles.includes('color')) {
+        properties.push('optionName');
+      }
+    } else if (['project', 'assortment'].includes(entityType)) {
+      properties.push('name');
+    }
+    return properties;
+
+  }
+
+  /** Returns the VibeIQ entity type from an entity.
+   * Throws error if it can't determine the entity type
+   *
+   * @param entity
+   * @returns string
+   */
+  static getEntityType(entity: any) {
+    let entityType = entity['entityType'];
+    if (!entityType) {
+      const typePath: string = entity['typePath'];
+      if (typePath) {
+        const types = typePath.split(':');
+        if (types && types[0]) {
+          entityType = types[0];
+        }
+      }
+    }
+    if (!entityType) {
+      throw Error(TypeDefaults.NO_ENTITY_TYPE);
+    }
+    return entityType;
+  }
+
+    /**Takes in full object and returns the default VibeIQ
+   * entity class.
+   *
+   * @param entity
+   * @returns string
+   */
+  static getDefaultEntityClass(object): string {
+    let entityClass = '';
+    let objectClass = TypeDefaults.getObjectClass(object);
+    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'
+    } else if('LCSColor' === objectClass){
+      entityClass = 'color';
+    } else if(['LCSSeason', 'SeasonGroup'].includes(objectClass)) {
+      entityClass = 'assortment';
+    } else if(customEntityClasses.includes(objectClass)) {
+      entityClass = 'custom-entity';
+    }
+
+    if(entityClass === '')
+      throw Error(TypeDefaults.NO_OBJECT_CLASS);
+
+    return entityClass;
+  }
+
+    /**Takes in full object and returns the default VibeIQ type path
+   * object class.
+   *
+   * @param object
+   * @returns string
+   */
+    static getDefaultEntityTypePath(object): string {
+      let typePath = '';
+      const objectClass = TypeDefaults.getObjectClass(object);
+
+      switch (objectClass) {
+        case 'LCSProduct':
+        case 'LCSSKU':
+          typePath = 'item';
+          break;
+        case 'LCSMaterial':
+          if (TypeDefaults.processLCSMaterialAsItem) {
+            typePath = 'item:material';
+          }
+          break;
+        case 'LCSProductSeasonLink':
+        case 'LCSSKUSeasonLink':
+          typePath = 'project-item';
+          break;
+        case 'LCSColor':
+          typePath = 'color';
+          break;
+        case 'LCSSeason':
+        case 'SeasonGroup':
+            typePath = 'assortment';
+          break;
+        }
+
+      if(typePath === '')
+        throw Error(TypeDefaults.NO_TYPE_PATH);
+
+      return typePath;
+    }
+
+      /**Takes in full entity and returns the slugs for the default identifier
+   *  properties. These properties are used when searching for an entity
+   * object class.
+   *
+   * @param entity
+   * @returns string[]
+   */
+
+  static getDefaultIdentifierPropertiesFromObject(object): string[] {
+    const identifierProps: string[] = [];
+    const objectClass = TypeDefaults.getObjectClass(object);
+
+    switch (objectClass) {
+      case 'LCSProduct':
+      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;
+      case 'SeasonGroup':
+        identifierProps.push('seasonGroupName');
+        break;
+      case 'LCSColor':
+      case 'LCSRevisableEntity':
+      case 'LCSLifecycleManaged':
+      case 'LCSLast':
+        identifierProps.push('name');
+        break;
+    }
+
+    return identifierProps;
+  }
+
+    /** Takes in full object and returns the slugs for informational
+   * properties.  These properties are helpful when debugging issues
+   * where the identifier properties don't find a match.
+   *
+   * @param object
+   * @returns string[]
+   */
+    static getDefaultInformationalPropertiesFromObject(object): string[] {
+      const objectClass = TypeDefaults.getObjectClass(object);
+      let properties:string[] = [];
+      const itemClasses = TypeDefaults.processLCSMaterialAsItem
+        ? ['LCSProduct', 'LCSMaterial']
+        : ['LCSProduct'];
+
+      if (itemClasses.includes(objectClass)) {
+        properties.push('name');
+      } else if ('LCSSKU' === objectClass) {
+        properties.push('optionName');
+      } else if (['LCSSeason', 'SeasonGroup'].includes(objectClass)) {
+        properties.push('name');
+      }
+      return properties;
+    }
+
+    static getObjectClass(object: any): string {
+      return (object)? object['flexPLMObjectClass']: '';
+    }
+}

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

@@ -0,0 +1,227 @@
+import { TypeUtils } from './type-utils';
+
+describe('TypeUtils.getEventObjectClass() tests', () =>{
+
+  const tu = new TypeUtils();
+
+  it('LCSProduct', () =>{
+    const entityType = 'item';
+    const newData = {
+      roles: ['family']
+    };
+
+    const objectClass = tu.getEventObjectClass(entityType, newData);
+
+    expect(objectClass).toEqual('LCSProduct');
+  });
+
+  it('LCSSKU', () =>{
+    const entityType = 'item';
+    const newData = {
+      roles: ['color']
+    };
+
+    const objectClass = tu.getEventObjectClass(entityType, newData);
+
+    expect(objectClass).toEqual('LCSSKU');
+  });
+
+  it('LCSProductSeasonLink', () =>{
+    const entityType = 'project-item';
+    const newData = {
+      roles: ['family']
+    };
+
+    const objectClass = tu.getEventObjectClass(entityType, newData);
+
+    expect(objectClass).toEqual('LCSProductSeasonLink');
+  });
+
+  it('LCSSKUSeasonLink', () =>{
+    const entityType = 'project-item';
+    const newData = {
+      roles: ['color']
+    };
+
+    const objectClass = tu.getEventObjectClass(entityType, newData);
+
+    expect(objectClass).toEqual('LCSSKUSeasonLink');
+  });
+  it('LCSColor', () =>{
+    const entityType = 'color';
+    const newData = {};
+
+    const objectClass = tu.getEventObjectClass(entityType, newData);
+
+    expect(objectClass).toEqual('LCSColor');
+  });
+
+  it('LCSRevisableEntity', () =>{
+    const entityType = 'custom-entity';
+    const newData = {};
+
+    const objectClass = tu.getEventObjectClass(entityType, newData);
+
+    expect(objectClass).toEqual('LCSRevisableEntity');
+  });
+
+});
+describe('filterProperties-item', () => {
+
+  const itemType = {
+    typePath: 'item'
+  };
+  itemType['typeProperties'] = [
+    {
+      id: 'H4NazLloHdUVhc71',
+      slug: 'null',
+      propertyLevel: null
+    },
+    {
+      id: 'H4NazLloHdUVhc71',
+      slug: 'family',
+      propertyLevel: 'family'
+    },
+    {
+      id: 'H4NazLloHdUVhc71',
+      slug: 'option',
+      propertyLevel: 'option'
+    },
+    {
+      id: 'H4NazLloHdUVhc71',
+      slug: 'overridable',
+      propertyLevel: 'overridable'
+    },
+    {
+      id: 'H4NazLloHdUVhc71',
+      slug: 'all',
+      propertyLevel: 'all'
+    },
+  ];
+  const tu = new TypeUtils();
+
+  it('item-family', () =>{
+    const len = 4;
+    const newData = {
+      roles: ['family']
+    };
+
+    const filteredProps = tu.filterTypeProperties(itemType, newData);
+    expect(filteredProps.length).toEqual(len);
+  });
+
+  it('item-option', () =>{
+    const len = 4;
+    const newData = {
+      roles: ['option']
+    };
+
+    const filteredProps = tu.filterTypeProperties(itemType, newData);
+    expect(filteredProps.length).toEqual(len);
+  });
+
+  it('item-no-roles', () =>{
+    const len = 5;
+    const newData = {
+    };
+
+    const filteredProps = tu.filterTypeProperties(itemType, newData);
+    expect(filteredProps.length).toEqual(len);
+  });
+});
+
+//project-item
+describe('filterProperties-project-item', () => {
+
+  const projectItemType = {
+    typePath: 'project-item'
+  };
+  projectItemType['typeProperties'] = [
+    {
+      id: 'H4NazLloHdUVhc71',
+      slug: 'null',
+      propertyLevel: null
+    },
+    {
+      id: 'H4NazLloHdUVhc71',
+      slug: 'family',
+      propertyLevel: 'family'
+    },
+    {
+      id: 'H4NazLloHdUVhc71',
+      slug: 'option',
+      propertyLevel: 'option'
+    },
+    {
+      id: 'H4NazLloHdUVhc71',
+      slug: 'overridable',
+      propertyLevel: 'overridable'
+    },
+    {
+      id: 'H4NazLloHdUVhc71',
+      slug: 'all',
+      propertyLevel: 'all'
+    },
+  ];
+  const tu = new TypeUtils();
+
+  it('item-family', () =>{
+    const len = 4;
+    const newData = {
+      roles: ['family']
+    };
+
+    const filteredProps = tu.filterTypeProperties(projectItemType, newData);
+    expect(filteredProps.length).toEqual(len);
+  });
+
+  it('item-option', () =>{
+    const len = 4;
+    const newData = {
+      roles: ['option']
+    };
+
+    const filteredProps = tu.filterTypeProperties(projectItemType, newData);
+    expect(filteredProps.length).toEqual(len);
+  });
+});
+
+//color
+describe('filterProperties-color', () => {
+  const colorType = {
+    typePath: 'color'
+  };
+  colorType['typeProperties'] = [
+    {
+      id: 'H4NazLloHdUVhc71',
+      slug: 'null',
+    },
+    {
+      id: 'H4NazLloHdUVhc71',
+      slug: 'family',
+    },
+    {
+      id: 'H4NazLloHdUVhc71',
+      slug: 'option',
+    },
+    {
+      id: 'H4NazLloHdUVhc71',
+      slug: 'overridable',
+    },
+    {
+      id: 'H4NazLloHdUVhc71',
+      slug: 'all',
+    },
+  ];
+  const tu = new TypeUtils();
+
+  it('color', () =>{
+    const len = 5;
+    const newData = {
+      roles: ['family']
+    };
+
+    const filteredProps = tu.filterTypeProperties(colorType, newData);
+    expect(filteredProps.length).toEqual(len);
+  });
+});

package/src/util/type-utils.ts

@@ -0,0 +1,144 @@
+import { Logger } from '@contrail/app-framework';
+import { TypeClientOptions, Types } from '@contrail/sdk';
+import { TypeProperty } from '@contrail/types';
+import { TypeConversionUtils } from './type-conversion-utils';
+
+export class TypeUtils {
+  private typesObj: Types;
+  constructor() {
+    this.typesObj = new Types();
+  }
+
+  async getTypeById(id) {
+    // this.logger.log('!-getTypeById: ' + id);
+    const type = await this.typesObj.getType({
+      id,
+      relations: ['typeProperties', 'typeInterfaces']
+    });
+    return type;
+  }
+
+  async getByRootAndPath(options: TypeClientOptions) {
+    const type = await this.typesObj.getByRootAndPath(options);
+    return type;
+  }
+
+  /** Deprecated: use TypeConversionUtils.getObjectTypePath() */
+  static getFlexPLMTypePath(entity) {
+    return entity['flexPLMTypePath'] || entity['flexTypePath'] || '';
+  }
+
+  /**  Deprecated: use TypeConversionUtils.getObjectClass()
+   *
+   * @param entityType
+   * @param newData
+   * @returns
+   */
+  getEventObjectClass(entityType: string, newData): string {
+    let objectClass = '';
+    if ('item' === entityType) {
+      if (newData.roles.includes('family')) {
+        objectClass = 'LCSProduct';
+      } else if (newData.roles.includes('color')) {
+        objectClass = 'LCSSKU';
+      }
+    } else if ('project-item' === entityType) {
+      if (newData.roles.includes('family')) {
+        objectClass = 'LCSProductSeasonLink';
+      } else if (newData.roles.includes('color')) {
+        objectClass = 'LCSSKUSeasonLink';
+      }
+    } else if ('color' === entityType) {
+      objectClass = 'LCSColor';
+    } else if ('custom-entity' === entityType) {
+      objectClass = 'LCSRevisableEntity';
+
+    }
+    return objectClass;
+  }
+
+  /** Gets the VibeIQ entity type for the object data
+   * @param data: object data
+   */
+  async getEntityTypeClientOptionsUsingMapping(transformMapFile, mapFileUtil, data): Promise<TypeClientOptions> {
+    const root = await TypeConversionUtils.getEntityClassFromObject(transformMapFile, mapFileUtil, data);
+    const path = await TypeConversionUtils.getEntityTypePathFromOjbect(transformMapFile, mapFileUtil, data);
+
+    let tco: TypeClientOptions = {
+      root,
+      path
+    };
+
+
+
+    return tco;
+  }
+
+  /** Gets the VibeIQ entity type for the object data
+   * @param objectClass: string object class
+   * @param data: object data
+   */
+  getEntityTypeClientOptions(objectClass: string, data): TypeClientOptions {
+    let tco: TypeClientOptions;
+    if (['LCSProduct', 'LCSSKU'].includes(objectClass)) {
+      tco = {
+        root: 'item'
+      };
+    } else if ('LCSSeason' === objectClass) {
+      tco = {
+        root: 'assortment'
+      };
+    } else if ('LCSColor' === objectClass) {
+      tco = {
+        root: 'color'
+      };
+    } else if (['LCSBusinessObject', 'LCSRevisableEntity', 'LCSLast'].includes(objectClass)) {
+      //TODO need to write logic using mapping file
+      tco = {
+        root: 'custom-entity'
+      };
+      console.log('data: ' + data);
+    }
+
+    return tco;
+  }
+  /** This will filter the properties based the newData entity.
+   * It is assumed the type is correct for the entity
+   *
+   * @param type entire type object
+   * @param newData the entity being processed
+   * @returns TypeProperty[] of applicable properties
+   */
+  filterTypeProperties(type, newData): TypeProperty[] {
+    let filteredProps: TypeProperty[] = type['typeProperties'];
+    const typePath = type['typePath'];
+    const roles = newData['roles'];
+    if (typePath && (typePath.startsWith('item') || typePath.startsWith('project-item'))) {
+      if (Logger.isDebugOn()) {
+        console.debug('filterTypeProperties():id: ' +newData?.id
+          + ', typePath: ' + typePath
+          + ', newData.roles: ' + newData?.roles);
+      }
+      if (roles) {
+        const isFamily = roles.includes('family');
+        if (Logger.isDebugOn()) {
+          console.debug('isFamily: ' + isFamily);
+        }
+
+        filteredProps = filteredProps.filter(prop => {
+          const propertyLevel = prop.propertyLevel;
+          const applies =
+            (isFamily && 'option' != propertyLevel) ||
+            (!isFamily && 'family' != propertyLevel);
+          return applies;
+        });
+
+      } else {
+        console.error('filterTypeProperties():Entity missing role-id: ' + newData['id']);
+      }
+    }
+
+    return filteredProps;
+  }
+
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "declaration": true,
+    "rootDir": "./src",
+    "outDir": "./lib",
+    "types": ["jest", "node"],
+    "experimentalDecorators": true,
+    "esModuleInterop": true,
+    "strictPropertyInitialization": false,
+    "noImplicitAny": false,
+    "allowSyntheticDefaultImports": true,
+    "emitDecoratorMetadata": true,
+    "removeComments": true,
+    "skipLibCheck": true,
+    "lib": [
+      "ES2020",
+      "dom",
+    ],
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "**/__tests__/*"]
+}