@contrail/flexplm 1.3.0-alpha.0 → 1.3.0-alpha.3

package/lib/util/type-utils.spec.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const type_utils_1 = require("./type-utils");
+describe('TypeUtils.getEventObjectClass() tests', () => {
+    const tu = new type_utils_1.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 type_utils_1.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);
+    });
+});
+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 type_utils_1.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);
+    });
+});
+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 type_utils_1.TypeUtils();
+    it('color', () => {
+        const len = 5;
+        const newData = {
+            roles: ['family']
+        };
+        const filteredProps = tu.filterTypeProperties(colorType, newData);
+        expect(filteredProps.length).toEqual(len);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/flexplm",
-  "version": "1.3.0-alpha.0",
+  "version": "1.3.0-alpha.3",
   "description": "Library used for integration with flexplm.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/publish.bat

@@ -1,5 +1,5 @@
-rd /s /q lib
-call npm install
-call npm run build
-call npm version patch
+rd /s /q lib
+call npm install
+call npm run build
+call npm version patch
 call npm publish

package/publish.sh

@@ -1,5 +1,5 @@
-rm -rf lib;
-npm install;
-npm run build;
-npm version patch;
+rm -rf lib;
+npm install;
+npm run build;
+npm version patch;
 npm publish;

package/src/entity-processor/base-entity-processor.spec.ts

@@ -3,6 +3,8 @@ import { MapFileUtil } from "@contrail/transform-data";
 import { EntityPayloadType, FCConfig } from "../interfaces/interfaces";
 import { DataConverter } from "../util/data-converter";
 import { BaseEntityProcessor, IncomingEntityResponse } from "./base-entity-processor";
+import { TypeConversionUtils } from "../util/type-conversion-utils";
+import { ThumbnailUtil } from "../util/thumbnail-util";
 
 const mockRootType = {
   typeProperties: [
@@ -335,4 +337,159 @@ describe('BaseEntityProcessor', () =>{
 
   });
 
+  describe('handleIncomingUpsert - inbound image sync', () =>{
+    const config = {} as FCConfig;
+    const mapFileUtil = new MapFileUtil(new Entities());
+    const dc = new DataConverter(config, mapFileUtil);
+    const mockEvent = { objectClass: 'TestClass', federatedId: 'fed-123', data: { name: 'test' }, entityReference: 'ref-1', eventType: 'PERSIST' } as EntityPayloadType;
+    const mockInboundData = { name: 'transformed-test' };
+    const mockCreatedEntity = { id: 'created-1', name: 'created', primaryViewableId: 'pv-created' };
+    const mockUpdatedEntity = { id: 'updated-1', name: 'updated', primaryViewableId: 'pv-updated' };
+    const mockExistingEntity = { id: 'existing-1', name: 'existing', typeId: 'type-1', roles: [] };
+
+    let btep: TestBaseEntityProcessor;
+    let syncInboundImagesSpy: jest.SpyInstance;
+    let syncThumbnailSpy: jest.SpyInstance;
+
+    beforeEach(() =>{
+      jest.clearAllMocks();
+      btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
+      jest.spyOn(btep, 'getTransformedData').mockResolvedValue(mockInboundData);
+      syncInboundImagesSpy = jest.spyOn(TypeConversionUtils, 'syncInboundImages');
+      syncThumbnailSpy = jest.spyOn(ThumbnailUtil.prototype, 'syncThumbnailToVibeIQ').mockResolvedValue(undefined);
+    });
+
+    it('should call updateEntity with thumbnail updates after create when syncInboundImages returns true', async () =>{
+      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: null });
+      jest.spyOn(btep, 'getCreateEntity' as any).mockResolvedValue({ entity: { name: 'new' } });
+      jest.spyOn(btep, 'createEntity').mockResolvedValue(mockCreatedEntity);
+      const updateEntitySpy = jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockCreatedEntity);
+      syncInboundImagesSpy.mockResolvedValue(true);
+      const thumbnailUpdates = { primaryViewableId: 'pv-new', primaryFileUrl: 'https://files/new.png' };
+      syncThumbnailSpy.mockResolvedValue(thumbnailUpdates);
+
+      const result = await btep.handleIncomingUpsert(mockEvent);
+
+      expect(syncThumbnailSpy).toBeCalledTimes(1);
+      expect(syncThumbnailSpy).toBeCalledWith({ entityId: 'created-1', primaryViewableId: 'pv-created', event: mockEvent, entityName: 'test' });
+      expect(updateEntitySpy).toBeCalledWith('test', mockCreatedEntity, thumbnailUpdates);
+      expect(result).toBe(mockCreatedEntity);
+    });
+
+    it('should not call updateEntity after create when syncThumbnailToVibeIQ returns undefined', async () =>{
+      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: null });
+      jest.spyOn(btep, 'getCreateEntity' as any).mockResolvedValue({ entity: { name: 'new' } });
+      jest.spyOn(btep, 'createEntity').mockResolvedValue(mockCreatedEntity);
+      const updateEntitySpy = jest.spyOn(btep, 'updateEntity');
+      syncInboundImagesSpy.mockResolvedValue(true);
+      syncThumbnailSpy.mockResolvedValue(undefined);
+
+      const result = await btep.handleIncomingUpsert(mockEvent);
+
+      expect(syncThumbnailSpy).toBeCalledTimes(1);
+      expect(updateEntitySpy).not.toHaveBeenCalled();
+      expect(result).toBe(mockCreatedEntity);
+    });
+
+    it('should not sync images after create when syncInboundImages returns false', async () =>{
+      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: null });
+      jest.spyOn(btep, 'getCreateEntity' as any).mockResolvedValue({ entity: { name: 'new' } });
+      jest.spyOn(btep, 'createEntity').mockResolvedValue(mockCreatedEntity);
+      syncInboundImagesSpy.mockResolvedValue(false);
+
+      const result = await btep.handleIncomingUpsert(mockEvent);
+
+      expect(syncInboundImagesSpy).toBeCalledTimes(1);
+      expect(syncThumbnailSpy).toBeCalledTimes(0);
+      expect(result).toBe(mockCreatedEntity);
+    });
+
+    it('should merge thumbnail updates with property diffs on update', async () =>{
+      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: mockExistingEntity });
+      jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({ name: 'changed' });
+      const updateEntitySpy = jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockUpdatedEntity);
+      syncInboundImagesSpy.mockResolvedValue(true);
+      const thumbnailUpdates = { primaryViewableId: 'pv-new' };
+      syncThumbnailSpy.mockResolvedValue(thumbnailUpdates);
+
+      const result = await btep.handleIncomingUpsert(mockEvent);
+
+      expect(syncThumbnailSpy).toBeCalledTimes(1);
+      expect(syncThumbnailSpy).toBeCalledWith({ entityId: 'existing-1', primaryViewableId: undefined, event: mockEvent, entityName: 'test' });
+      expect(updateEntitySpy).toBeCalledWith('test', mockExistingEntity, { name: 'changed', primaryViewableId: 'pv-new' });
+      expect(result).toBe(mockUpdatedEntity);
+    });
+
+    it('should update entity with only thumbnail changes when no property diffs', async () =>{
+      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: mockExistingEntity });
+      jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({});
+      const updateEntitySpy = jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockUpdatedEntity);
+      syncInboundImagesSpy.mockResolvedValue(true);
+      const thumbnailUpdates = { primaryViewableId: 'pv-new' };
+      syncThumbnailSpy.mockResolvedValue(thumbnailUpdates);
+
+      const result = await btep.handleIncomingUpsert(mockEvent);
+
+      expect(updateEntitySpy).toBeCalledWith('test', mockExistingEntity, { primaryViewableId: 'pv-new' });
+      expect(result).toBe(mockUpdatedEntity);
+    });
+
+    it('should not sync images on update when syncInboundImages returns false', async () =>{
+      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: mockExistingEntity });
+      jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({ name: 'changed' });
+      jest.spyOn(btep, 'updateEntity').mockResolvedValue(mockUpdatedEntity);
+      syncInboundImagesSpy.mockResolvedValue(false);
+
+      const result = await btep.handleIncomingUpsert(mockEvent);
+
+      expect(syncInboundImagesSpy).toBeCalledTimes(1);
+      expect(syncThumbnailSpy).toBeCalledTimes(0);
+      expect(result).toBe(mockUpdatedEntity);
+    });
+
+    it('should not sync images on early return from getIncomingEntity', async () =>{
+      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({
+        earlyReturn: { status: 400, data: { message: 'error' }, shortStatusMessage: 'FAIL' }
+      });
+
+      await btep.handleIncomingUpsert(mockEvent);
+
+      expect(syncInboundImagesSpy).toBeCalledTimes(0);
+      expect(syncThumbnailSpy).toBeCalledTimes(0);
+    });
+
+    it('should not sync images on early return from getCreateEntity', async () =>{
+      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: null });
+      jest.spyOn(btep, 'getCreateEntity' as any).mockResolvedValue({
+        earlyReturn: { status: 400, data: { message: 'not creatable' }, shortStatusMessage: 'NOT_CREATABLE' }
+      });
+
+      await btep.handleIncomingUpsert(mockEvent);
+
+      expect(syncInboundImagesSpy).toBeCalledTimes(0);
+      expect(syncThumbnailSpy).toBeCalledTimes(0);
+    });
+
+    it('should return no changes when no property diffs and no thumbnail updates', async () =>{
+      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: mockExistingEntity });
+      jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({});
+      syncInboundImagesSpy.mockResolvedValue(true);
+      syncThumbnailSpy.mockResolvedValue(undefined);
+
+      const result = await btep.handleIncomingUpsert(mockEvent);
+
+      expect(result).toEqual({ status: 200, data: { message: 'No Changes to persist for entity: existing-1' } });
+    });
+
+    it('should return no changes when syncInboundImages is false and no property diffs', async () =>{
+      jest.spyOn(btep, 'getIncomingEntity' as any).mockResolvedValue({ entity: mockExistingEntity });
+      jest.spyOn(btep, 'getUpdatesForEntity').mockResolvedValue({});
+      syncInboundImagesSpy.mockResolvedValue(false);
+
+      const result = await btep.handleIncomingUpsert(mockEvent);
+
+      expect(result).toEqual({ status: 200, data: { message: 'No Changes to persist for entity: existing-1' } });
+    });
+  });
+
 });

package/src/entity-processor/base-entity-processor.ts

@@ -7,6 +7,7 @@ import { MapFileUtil } from '@contrail/transform-data';
 import { Entities } from '@contrail/sdk';
 import { TypeProperty } from '@contrail/types';
 import { TypeConversionUtils } from '../util/type-conversion-utils';
+import { ThumbnailUtil } from '../util/thumbnail-util';
 import { EventShortMessageStatus } from '../util/event-short-message-status';
 
 const UNSUPPORTED_TYPE = 'Unsupported eventType.';
@@ -84,6 +85,15 @@ export abstract class BaseEntityProcessor {
         return createEntityResponse.earlyReturn;
       }
       const createdEntity = await this.createEntity(this.baseType, createEntityResponse.entity);
+      const shouldSyncThumbnail = await TypeConversionUtils.syncInboundImages(
+        this.transformMapFile, this.mapFileUtil, event.data
+      );
+      if (shouldSyncThumbnail) {
+        const thumbnailUpdates = await new ThumbnailUtil(this.config).syncThumbnailToVibeIQ({ entityId: createdEntity.id, primaryViewableId: createdEntity.primaryViewableId, event, entityName: this.baseType });
+        if (thumbnailUpdates) {
+          await this.updateEntity(this.baseType, createdEntity, thumbnailUpdates);
+        }
+      }
       const statusMsg = this.getInboundStatusMessage({
         status: EventShortMessageStatus.SUCCESS,
         statusMessage: EventShortMessageStatus.CREATED,
@@ -96,7 +106,16 @@ export abstract class BaseEntityProcessor {
     }
 
     const diffs = await this.getUpdatesForEntity(entity, inboundData);
-    if(Object.getOwnPropertyNames(diffs).length == 0){
+    const shouldSyncThumbnail = await TypeConversionUtils.syncInboundImages(
+      this.transformMapFile, this.mapFileUtil, event.data
+    );
+    let thumbnailUpdates;
+    if (shouldSyncThumbnail) {
+      thumbnailUpdates = await new ThumbnailUtil(this.config).syncThumbnailToVibeIQ({ entityId: entity.id, primaryViewableId: entity.primaryViewableId, event, entityName: this.baseType });
+    }
+
+    const allUpdates = { ...diffs, ...thumbnailUpdates };
+    if(Object.getOwnPropertyNames(allUpdates).length == 0){
       const statusMsg = this.getInboundStatusMessage({
         status: EventShortMessageStatus.SUCCESS,
         statusMessage: EventShortMessageStatus.NO_CHANGES,
@@ -112,7 +131,7 @@ export abstract class BaseEntityProcessor {
       };
     }
 
-    const updatedEntity  = await this.updateEntity(this.baseType, entity, diffs);
+    const updatedEntity  = await this.updateEntity(this.baseType, entity, allUpdates);
     const statusMsg = this.getInboundStatusMessage({
       status: EventShortMessageStatus.SUCCESS,
       statusMessage: EventShortMessageStatus.UPDATED,

package/src/flexplm-request.ts

@@ -1,28 +1,28 @@
-import axios, { AxiosRequestConfig } from 'axios';
-
-const BASE_URL: string = 'https://PP-2006031951wo.portal.ptc.io/Windchill/servlet/rest/cdee';
-const BASE_CONFIG: AxiosRequestConfig = {
-  method: 'POST',
-  headers: {
-    'Accept': 'application/json',
-    'Content-Type': 'application/json',
-    'CSRF_NONCE': '2OaLp+0dWNBtrkTwtdDC491zaacu6Hykvqi/lpl6bZgJ/QXBrK/B1J5FErMkmAmktr/I3thcbO1Xn3HJ7Ne/l9kpaedUmn7H75Xey4ZbNLsenW+anM3vxIZ7ELosk3k=',
-    'Authorization': 'Basic d2NhZG1pbjpSZXRhaWwyMDIwLQ==',
-    'Cookie': 'JSESSIONID=36D5B3C74C1F963C6C73E9AF5B6BDA78.tomcat1; JSESSIONID=B8090C802D8548EA773C97F5886FAB79.tomcat1',
-  },
-};
-
-export class FlexPLMRequest {
-  static async request(path: string, data: any){
-    const config = Object.assign({}, BASE_CONFIG);
-    config.url = BASE_URL + path;
-    config.data = data;
-    try {
-      const resp = await axios(config);
-      return Promise.resolve(resp.data);
-    } catch (error) {
-      console.error(`${FlexPLMRequest} error: ${error.message}`);
-      return Promise.resolve(null);
-    }
-  }
-}
+import axios, { AxiosRequestConfig } from 'axios';
+
+const BASE_URL: string = 'https://PP-2006031951wo.portal.ptc.io/Windchill/servlet/rest/cdee';
+const BASE_CONFIG: AxiosRequestConfig = {
+  method: 'POST',
+  headers: {
+    'Accept': 'application/json',
+    'Content-Type': 'application/json',
+    'CSRF_NONCE': '2OaLp+0dWNBtrkTwtdDC491zaacu6Hykvqi/lpl6bZgJ/QXBrK/B1J5FErMkmAmktr/I3thcbO1Xn3HJ7Ne/l9kpaedUmn7H75Xey4ZbNLsenW+anM3vxIZ7ELosk3k=',
+    'Authorization': 'Basic d2NhZG1pbjpSZXRhaWwyMDIwLQ==',
+    'Cookie': 'JSESSIONID=36D5B3C74C1F963C6C73E9AF5B6BDA78.tomcat1; JSESSIONID=B8090C802D8548EA773C97F5886FAB79.tomcat1',
+  },
+};
+
+export class FlexPLMRequest {
+  static async request(path: string, data: any){
+    const config = Object.assign({}, BASE_CONFIG);
+    config.url = BASE_URL + path;
+    config.data = data;
+    try {
+      const resp = await axios(config);
+      return Promise.resolve(resp.data);
+    } catch (error) {
+      console.error(`${FlexPLMRequest} error: ${error.message}`);
+      return Promise.resolve(null);
+    }
+  }
+}

package/src/flexplm-utils.spec.ts

@@ -1,27 +1,27 @@
-import { FlexPLMUtils } from './flexplm-utils';
-
-describe('Types Controller', () => {
-
-  beforeEach(async () => {
-  });
-
-  it('should convert a type path', () => {
-    expect(FlexPLMUtils.convertTypePath('Product')).toEqual('product');
-    expect(FlexPLMUtils.convertTypePath('Product\\Apparel')).toEqual('product:apparel');
-    expect(FlexPLMUtils.convertTypePath('Product\\Skin Care')).toEqual('product:skin_care');
-    expect(FlexPLMUtils.convertTypePath('Product\\Apparel\\Shirt')).toEqual('product:apparel:shirt');
-    expect(FlexPLMUtils.convertTypePath('Product\\Apparel\\[Shirt]')).toEqual('product:apparel:*shirt*');
-    expect(FlexPLMUtils.convertTypePath('')).toBeNull();
-  });
-  it('should compute level in tree', () => {
-    expect(FlexPLMUtils.computeLevelFromPath('product')).toEqual(1);
-    expect(FlexPLMUtils.computeLevelFromPath('product:apparel')).toEqual(2);
-    expect(FlexPLMUtils.computeLevelFromPath('product:apparel:dress:mini')).toEqual(4);
-  });
-  it('should get a parent type path', () => {
-    expect(FlexPLMUtils.getParentTypePath('product')).toBeNull();
-    expect(FlexPLMUtils.getParentTypePath('product:apparel')).toEqual('product');
-    expect(FlexPLMUtils.getParentTypePath('product:apparel:stuff')).toEqual('product:apparel');
-    expect(FlexPLMUtils.getParentTypePath('Product\\Apparel')).toEqual('product');
-  });
-});
+import { FlexPLMUtils } from './flexplm-utils';
+
+describe('Types Controller', () => {
+
+  beforeEach(async () => {
+  });
+
+  it('should convert a type path', () => {
+    expect(FlexPLMUtils.convertTypePath('Product')).toEqual('product');
+    expect(FlexPLMUtils.convertTypePath('Product\\Apparel')).toEqual('product:apparel');
+    expect(FlexPLMUtils.convertTypePath('Product\\Skin Care')).toEqual('product:skin_care');
+    expect(FlexPLMUtils.convertTypePath('Product\\Apparel\\Shirt')).toEqual('product:apparel:shirt');
+    expect(FlexPLMUtils.convertTypePath('Product\\Apparel\\[Shirt]')).toEqual('product:apparel:*shirt*');
+    expect(FlexPLMUtils.convertTypePath('')).toBeNull();
+  });
+  it('should compute level in tree', () => {
+    expect(FlexPLMUtils.computeLevelFromPath('product')).toEqual(1);
+    expect(FlexPLMUtils.computeLevelFromPath('product:apparel')).toEqual(2);
+    expect(FlexPLMUtils.computeLevelFromPath('product:apparel:dress:mini')).toEqual(4);
+  });
+  it('should get a parent type path', () => {
+    expect(FlexPLMUtils.getParentTypePath('product')).toBeNull();
+    expect(FlexPLMUtils.getParentTypePath('product:apparel')).toEqual('product');
+    expect(FlexPLMUtils.getParentTypePath('product:apparel:stuff')).toEqual('product:apparel');
+    expect(FlexPLMUtils.getParentTypePath('Product\\Apparel')).toEqual('product');
+  });
+});

package/src/flexplm-utils.ts

@@ -1,29 +1,29 @@
-export class FlexPLMUtils {
-  static convertTypePath = (path: string): string => {
-    if (!path) { return null; }
-    let newPath = path;
-    while (newPath.indexOf('\\') > 1) {
-      newPath = newPath.replace('\\', ':');
-    }
-    while (newPath.indexOf('[') > 1) {
-      newPath = newPath.replace('[', '*');
-    }
-    while (newPath.indexOf(']') > 1) {
-      newPath = newPath.replace(']', '*');
-    }
-   while (newPath.indexOf(' ') > 1) {
-      newPath = newPath.replace(' ', '_');
-    }
-    newPath = newPath.toLowerCase();
-    return newPath;
-  }
-
-  static getParentTypePath = (path: string): string => {
-    const newPath = FlexPLMUtils.convertTypePath(path);
-    return (!newPath || newPath.indexOf(':') < 0) ? null : newPath.substring(0, newPath.lastIndexOf(':'));
-  }
-
-  static computeLevelFromPath(path: string) {
-    return (path.match(/:/g) || []).length + 1;
-  }
-}
+export class FlexPLMUtils {
+  static convertTypePath = (path: string): string => {
+    if (!path) { return null; }
+    let newPath = path;
+    while (newPath.indexOf('\\') > 1) {
+      newPath = newPath.replace('\\', ':');
+    }
+    while (newPath.indexOf('[') > 1) {
+      newPath = newPath.replace('[', '*');
+    }
+    while (newPath.indexOf(']') > 1) {
+      newPath = newPath.replace(']', '*');
+    }
+   while (newPath.indexOf(' ') > 1) {
+      newPath = newPath.replace(' ', '_');
+    }
+    newPath = newPath.toLowerCase();
+    return newPath;
+  }
+
+  static getParentTypePath = (path: string): string => {
+    const newPath = FlexPLMUtils.convertTypePath(path);
+    return (!newPath || newPath.indexOf(':') < 0) ? null : newPath.substring(0, newPath.lastIndexOf(':'));
+  }
+
+  static computeLevelFromPath(path: string) {
+    return (path.match(/:/g) || []).length + 1;
+  }
+}

package/src/index.ts

@@ -1,22 +1,22 @@
-export * from './flexplm-request';
-export * from './flexplm-utils';
-export * from './util/config-defaults';
-export * from './util/data-converter';
-export * from './util/error-response-object';
-export * from './util/event-short-message-status';
-export * from './util/federation';
-export * from './util/flexplm-connect';
-export * from './interfaces/interfaces';
-export * from './util/logger-config';
-export * from './util/thumbnail-util';
-export * from './util/type-conversion-utils';
-export * from './util/type-defaults';
-export * from './util/type-utils';
-export * from './util/map-utils';
-export * from './interfaces/interfaces';
-export * from './interfaces/item-family-changes';
-export * from './interfaces/publish-change-data';
-export * from './publish/base-process-publish-assortment';
-export * from './publish/base-process-publish-assortment-callback';
-export * from './entity-processor/base-entity-processor';
+export * from './flexplm-request';
+export * from './flexplm-utils';
+export * from './util/config-defaults';
+export * from './util/data-converter';
+export * from './util/error-response-object';
+export * from './util/event-short-message-status';
+export * from './util/federation';
+export * from './util/flexplm-connect';
+export * from './interfaces/interfaces';
+export * from './util/logger-config';
+export * from './util/thumbnail-util';
+export * from './util/type-conversion-utils';
+export * from './util/type-defaults';
+export * from './util/type-utils';
+export * from './util/map-utils';
+export * from './interfaces/interfaces';
+export * from './interfaces/item-family-changes';
+export * from './interfaces/publish-change-data';
+export * from './publish/base-process-publish-assortment';
+export * from './publish/base-process-publish-assortment-callback';
+export * from './entity-processor/base-entity-processor';
 export * from './transform/identifier-conversion';