@contrail/flexplm 1.1.13 → 1.1.14

package/src/util/type-defaults.ts

@@ -0,0 +1,261 @@
+import { MapFileUtil } from "@contrail/transform-data";
+
+
+export class TypeDefaults {
+  static NO_ENTITY_TYPE = 'Not able to determine the entity type of the entity object';
+  constructor() {
+  }
+  /**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 = [];
+    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);
+    if(['LCSProduct', 'LCSSKU'].includes(objectClass)){
+      entityClass = 'item';
+    } else if('LCSColor' === objectClass){
+      entityClass = 'color';
+    }
+
+    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':
+        case 'LCSProductSeasonLink':
+        case 'LCSSKUSeasonLink':
+          typePath = 'item';
+          break;
+        case 'LCSColor':
+          typePath = 'color';
+          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 getDefaultIdentifierPropertiesFromObject(object): string[] {
+    const identifierProps = [];
+    const objectClass = TypeDefaults.getObjectClass(object);
+
+    switch (objectClass) {
+      case 'LCSProduct':
+      case 'LCSSKU':
+          identifierProps.push('itemNumber');
+        break;
+      case 'LCSSeason':
+        identifierProps.push('flexPLMSeasonName');
+        break;
+      case 'SeasonGroup':
+        identifierProps.push('seasonGroupName');
+        break;
+      case 'LCSColor':
+      case 'LCSRevisableEntity':
+      case 'LCSLifecycleManaged':
+        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[] = [];
+      if ('LCSProduct' === 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['objectClass']: '';
+    }
+}

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,124 @@
+import { Logger } from '@contrail/app-framework';
+import { TypeClientOptions, Types } from '@contrail/sdk';
+import { TypeProperty } from '@contrail/types';
+
+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;
+  }
+
+  static getFlexPLMTypePath(entity) {
+    return entity['flexPLMTypePath'] || entity['flexTypePath'] || '';
+  }
+
+  /** Gets the FlexPLM class for the entity data
+   *
+   * @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 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'];
+    if (typePath && (typePath.startsWith('item') || typePath.startsWith('project-item'))) {
+      if (Logger.isDebugOn()) {
+        console.debug('typePath: ' + typePath);
+        console.debug('newData: ' + JSON.stringify(newData));
+      }
+      const 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,27 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./lib",
+    "experimentalDecorators": true,
+    "esModuleInterop": true,
+    "strictPropertyInitialization": false,
+    "noImplicitAny": false,
+    "allowSyntheticDefaultImports": true,
+    "emitDecoratorMetadata": true,
+    "removeComments": true,
+    "skipLibCheck": true,
+    "lib": [
+      "es5",
+      "ES2015",
+      "ES2016",
+      "ES2017",
+      "ES2020",
+      "dom",
+      "esnext.asynciterable"
+    ],    
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "**/__tests__/*"]
+}

package/tslint.json

@@ -0,0 +1,57 @@
+{
+  "defaultSeverity": "error",
+  "extends": [
+    "tslint:recommended"
+  ],
+  "jsRules": {
+    "no-unused-expression": true
+  },
+  "rules": {
+    "eofline": false,
+    "quotemark": [
+      true,
+      "single"
+    ],
+    "no-shadowed-variable": false,
+    "indent": false,
+    "member-access": [
+      false
+    ],
+    "no-string-literal": false,
+    "ordered-imports": [
+      false
+    ],
+    "max-line-length": [
+      false,
+      150
+    ],
+    "member-ordering": [
+      false
+    ],
+    "curly": false,
+    "interface-name": [
+      false
+    ],
+    "array-type": [
+      false
+    ],
+    "no-empty-interface": false,
+    "no-empty": false,
+    "arrow-parens": false,
+    "object-literal-sort-keys": false,
+    "no-unused-expression": false,
+    "max-classes-per-file": [
+      false
+    ],
+    "variable-name": [
+      false
+    ],
+    "one-line": [
+      false
+    ],
+    "one-variable-per-declaration": [
+      false
+    ]
+  },
+  "rulesDirectory": []
+}