@contrail/flexplm 1.1.12 → 1.1.14

package/lib/util/data-converter.spec.js

@@ -0,0 +1,591 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mockObj1234 = {
+    id: 1234,
+    typePath: 'color'
+};
+const mockObj2222 = {
+    id: 2222,
+    typePath: 'color'
+};
+const mockGetFunction = jest.fn((options) => {
+    return (options?.criteria?.id === 1234)
+        ? [mockObj1234]
+        : [mockObj2222];
+});
+jest.mock('@contrail/sdk', () => {
+    const origModule = jest.requireActual('@contrail/sdk');
+    return {
+        __esModule: true,
+        ...origModule,
+        Entities: class {
+            constructor() {
+                this.get = mockGetFunction;
+            }
+        },
+    };
+});
+const sdk_1 = require("@contrail/sdk");
+const transform_data_1 = require("@contrail/transform-data");
+const data_converter_1 = require("./data-converter");
+const type_conversion_utils_1 = require("./type-conversion-utils");
+const map_utils_1 = require("./map-utils");
+describe('getFlexPLMValue multi_select', () => {
+    const config = {
+        apiHost: 'host',
+        userName: () => 'user',
+        password: () => 'pass',
+        urlContext: 'xxx',
+        vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+        csrfEndpoint: '/servlet/rest/security/csrf',
+        itemPreDevelopmentLifecycleStages: ['concept']
+    };
+    const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+    const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+    const enumAtt = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'multi_select',
+        slug: 'flexMultiSelect',
+        label: 'Flex Multi Select',
+        options: [
+            {
+                value: 'one',
+                display: 'One'
+            },
+            {
+                value: 'two',
+                display: 'Two'
+            },
+            {
+                value: 'three',
+                display: 'Three'
+            }
+        ],
+    };
+    it('multi_select_null', async () => {
+        const newData = {
+            flexMultiSelect: null
+        };
+        const returnValue = await dc.getFlexPLMValue(enumAtt, newData, true);
+        expect(returnValue).toEqual([]);
+    });
+    it('multi_select_no_values', async () => {
+        const newData = {
+            flexMultiSelect: []
+        };
+        const returnValue = await dc.getFlexPLMValue(enumAtt, newData, true);
+        expect(returnValue).toEqual(newData.flexMultiSelect);
+    });
+    it('multi_select_two_values', async () => {
+        const newData = {
+            flexMultiSelect: ['one', 'three']
+        };
+        const optionValues = [
+            { value: 'one', display: 'One' },
+            { value: 'three', display: 'Three' }
+        ];
+        const returnValue = await dc.getFlexPLMValue(enumAtt, newData, true);
+        expect(returnValue).toEqual(optionValues);
+    });
+});
+describe('getEnumerationValue', () => {
+    const config = {
+        apiHost: 'host',
+        userName: () => 'user',
+        password: () => 'pass',
+        urlContext: 'xxx',
+        vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+        csrfEndpoint: '/servlet/rest/security/csrf',
+        itemPreDevelopmentLifecycleStages: ['concept']
+    };
+    const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+    const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+    const enumProp = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'choice',
+        slug: 'flexChoice',
+        label: 'Flex Choice',
+        options: [
+            {
+                value: 'one',
+                display: 'One'
+            },
+            {
+                value: 'two',
+                display: 'Two'
+            },
+            {
+                value: 'three',
+                display: 'Three'
+            }
+        ],
+    };
+    const enumPropNoList = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'choice',
+        slug: 'flexChoice',
+        label: 'Flex Choice',
+    };
+    it('match 1 key', () => {
+        const nd = 'one';
+        const expectedValue = { value: 'one', display: 'One' };
+        const returnValue = dc.getEnumerationValue(enumProp, nd);
+        expect(returnValue).toEqual(expectedValue);
+    });
+    it('wrong key', () => {
+        const nd = 'one1';
+        const expectedValue = {};
+        const returnValue = dc.getEnumerationValue(enumProp, nd);
+        expect(returnValue).toEqual(expectedValue);
+    });
+    it('property no list', () => {
+        const nd = 'one1';
+        const expectedValue = {};
+        const returnValue = dc.getEnumerationValue(enumPropNoList, nd);
+        expect(returnValue).toEqual(expectedValue);
+    });
+});
+describe('getEnumerationValue multi_select', () => {
+    const config = {
+        apiHost: 'host',
+        userName: () => 'user',
+        password: () => 'pass',
+        urlContext: 'xxx',
+        vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+        csrfEndpoint: '/servlet/rest/security/csrf',
+        itemPreDevelopmentLifecycleStages: ['concept']
+    };
+    const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+    const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+    const enumAtt = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'multi_select',
+        slug: 'flexMultiSelect',
+        label: 'Flex Multi Select',
+        options: [
+            {
+                value: 'one',
+                display: 'One'
+            },
+            {
+                value: 'two',
+                display: 'Two'
+            },
+            {
+                value: 'three',
+                display: 'Three'
+            }
+        ],
+    };
+    it('multi_select_null', async () => {
+        const nd = null;
+        const returnValue = await dc.getEnumerationValue(enumAtt, nd);
+        expect(returnValue).toEqual([]);
+    });
+    it('multi_select_no_values', async () => {
+        const nd = [];
+        const returnValue = await dc.getEnumerationValue(enumAtt, nd);
+        expect(returnValue).toEqual(nd);
+    });
+    it('multi select one string value', async () => {
+        const nd = 'one';
+        const optionValues = [
+            { value: 'one', display: 'One' }
+        ];
+        const returnValue = await dc.getEnumerationValue(enumAtt, nd);
+        expect(returnValue).toEqual(optionValues);
+    });
+    it('multi_select_two_values', async () => {
+        const nd = ['one', 'three'];
+        const optionValues = [
+            { value: 'one', display: 'One' },
+            { value: 'three', display: 'Three' }
+        ];
+        const returnValue = await dc.getEnumerationValue(enumAtt, nd);
+        expect(returnValue).toEqual(optionValues);
+    });
+});
+describe('getPersistableChanges', () => {
+    const config = {
+        apiHost: 'host',
+        userName: () => 'user',
+        password: () => 'pass',
+        urlContext: 'xxx',
+        vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+        csrfEndpoint: '/servlet/rest/security/csrf',
+        itemPreDevelopmentLifecycleStages: ['concept']
+    };
+    const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+    const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+    it('no changes', () => {
+        const entity = {
+            num: 1
+        };
+        const potentialChanges = {};
+        const diffs = dc.getPersistableChanges(entity, potentialChanges);
+        expect(Object.getOwnPropertyNames(diffs).length).toEqual(0);
+    });
+    it('same value', () => {
+        const entity = {
+            str: 'test',
+            num: 1
+        };
+        const potentialChanges = {
+            str: 'test',
+            num: 1
+        };
+        const diffs = dc.getPersistableChanges(entity, potentialChanges);
+        expect(Object.getOwnPropertyNames(diffs).length).toEqual(0);
+    });
+    it('diff num value', () => {
+        const entity = {
+            str: 'option 1 string-Changed',
+            num: 12
+        };
+        const potentialChanges = {
+            str: 'option 1 string-Changed',
+            num: 1
+        };
+        const diffs = dc.getPersistableChanges(entity, potentialChanges);
+        expect(Object.getOwnPropertyNames(diffs).length).toEqual(1);
+        expect(diffs['num']).toEqual(potentialChanges['num']);
+    });
+    it('zero num value', () => {
+        const entity = {
+            str: 'option 1 string-Changed',
+            num: 12
+        };
+        const potentialChanges = {
+            str: 'option 1 string-Changed',
+            num: 0
+        };
+        const diffs = dc.getPersistableChanges(entity, potentialChanges);
+        expect(Object.getOwnPropertyNames(diffs).length).toEqual(1);
+        expect(diffs['num']).toEqual(potentialChanges['num']);
+    });
+    it('diff str value', () => {
+        const entity = {
+            str: 'test',
+            num: 1
+        };
+        const potentialChanges = {
+            str: 'test-1',
+            num: 1
+        };
+        const diffs = dc.getPersistableChanges(entity, potentialChanges);
+        expect(Object.getOwnPropertyNames(diffs).length).toEqual(1);
+        expect(diffs['str']).toEqual(potentialChanges['str']);
+    });
+    it('empty str value', () => {
+        const entity = {
+            str: 'test',
+            num: 1
+        };
+        const potentialChanges = {
+            str: '',
+            num: 1
+        };
+        const diffs = dc.getPersistableChanges(entity, potentialChanges);
+        expect(Object.getOwnPropertyNames(diffs).length).toEqual(1);
+        expect(diffs['str']).toEqual(potentialChanges['str']);
+    });
+});
+describe('getObjectReferenceValue cache', () => {
+    const config = {
+        apiHost: 'host',
+        userName: () => 'user',
+        password: () => 'pass',
+        urlContext: 'xxx',
+        vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+        csrfEndpoint: '/servlet/rest/security/csrf',
+        itemPreDevelopmentLifecycleStages: ['concept']
+    };
+    const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+    const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+    const ref1Prop = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'object_reference',
+        slug: 'ref1',
+        label: 'Object Ref#1',
+        referencedTypeRootSlug: 'color'
+    };
+    const ref2Prop = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'object_reference',
+        slug: 'ref2',
+        label: 'Object Ref#2',
+        referencedTypeRootSlug: 'color'
+    };
+    const ref3Prop = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'object_reference',
+        slug: 'ref3',
+        label: 'Object Ref#3',
+        referencedTypeRootSlug: 'color'
+    };
+    const newData = {
+        ref1Id: 1234,
+        ref2Id: 2222,
+        ref3Id: 1234
+    };
+    it('cache hit', async () => {
+        const oobFunction = dc.getFlexPLMObjectData;
+        try {
+            dc.getFlexPLMObjectData = async (newData) => {
+                return newData;
+            };
+            mockGetFunction.mockClear();
+            const r1 = await dc.getObjectReferenceValue(ref1Prop, newData, true);
+            const r2 = await dc.getObjectReferenceValue(ref2Prop, newData, true);
+            const r3 = await dc.getObjectReferenceValue(ref3Prop, newData, true);
+            expect(mockGetFunction).toHaveBeenCalledTimes(2);
+            expect(r1).toEqual(mockObj1234);
+            expect(r2).toEqual(mockObj2222);
+            expect(r3).toEqual(mockObj1234);
+        }
+        finally {
+            dc.getFlexPLMObjectData = oobFunction;
+        }
+    });
+});
+describe('getObjectReferenceValue bad value', () => {
+    const config = {
+        apiHost: 'host',
+        userName: () => 'user',
+        password: () => 'pass',
+        urlContext: 'xxx',
+        vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+        csrfEndpoint: '/servlet/rest/security/csrf',
+        itemPreDevelopmentLifecycleStages: ['concept']
+    };
+    const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+    const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+    const ref1Prop = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'object_reference',
+        slug: 'ref1',
+        label: 'Object Ref#1',
+        referencedTypeRootSlug: 'color'
+    };
+    const ref2Prop = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'object_reference',
+        slug: 'ref2',
+        label: 'Object Ref#2',
+        referencedTypeRootSlug: 'color'
+    };
+    const ref3Prop = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'object_reference',
+        slug: 'ref3',
+        label: 'Object Ref#3',
+        referencedTypeRootSlug: 'color'
+    };
+    const newData = {
+        ref1Id: 1234,
+        ref2Id: 2222,
+        ref3Id: 1234,
+        ref3: 'old value'
+    };
+    it('old string value', async () => {
+        const oobFunction = dc.getFlexPLMObjectData;
+        try {
+            dc.getFlexPLMObjectData = async (newData) => {
+                return newData;
+            };
+            mockGetFunction.mockClear();
+            const r3 = await dc.getObjectReferenceValue(ref3Prop, newData, true);
+            expect(r3).toEqual(mockObj1234);
+        }
+        finally {
+            dc.getFlexPLMObjectData = oobFunction;
+        }
+    });
+    it('only id', async () => {
+        const oobFunction = dc.getFlexPLMObjectData;
+        try {
+            dc.getFlexPLMObjectData = async (newData) => {
+                return newData;
+            };
+            mockGetFunction.mockClear();
+            const r2 = await dc.getObjectReferenceValue(ref2Prop, newData, true);
+            expect(r2).toEqual(mockObj2222);
+        }
+        finally {
+            dc.getFlexPLMObjectData = oobFunction;
+        }
+    });
+    it('already references object', async () => {
+        const testData = {
+            ref1Id: 1234,
+            ref1: mockObj1234,
+            ref2Id: 2222,
+            ref3Id: 1234,
+            ref3: 'old value'
+        };
+        const oobFunction = dc.getFlexPLMObjectData;
+        try {
+            dc.getFlexPLMObjectData = async (newData) => {
+                return newData;
+            };
+            mockGetFunction.mockClear();
+            const r1 = await dc.getObjectReferenceValue(ref1Prop, testData, true);
+            expect(r1).toEqual(mockObj1234);
+        }
+        finally {
+            dc.getFlexPLMObjectData = oobFunction;
+        }
+    });
+    it('old string value, no refId', async () => {
+        const testData = {
+            ref1: 'old value'
+        };
+        const oobFunction = dc.getFlexPLMObjectData;
+        try {
+            dc.getFlexPLMObjectData = async (newData) => {
+                return newData;
+            };
+            mockGetFunction.mockClear();
+            const r1 = await dc.getObjectReferenceValue(ref1Prop, testData, true);
+            expect(r1).toEqual({});
+        }
+        finally {
+            dc.getFlexPLMObjectData = oobFunction;
+        }
+    });
+});
+describe('getObjectReferenceValue - use mapping', () => {
+    const maps = require('./data-converter-spec-mockData');
+    const mapping = maps['mapping'];
+    const config = {
+        apiHost: 'host',
+        userName: () => 'user',
+        password: () => 'pass',
+        urlContext: 'xxx',
+        transformMapFile: 'file1',
+        vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+        csrfEndpoint: '/servlet/rest/security/csrf',
+        itemPreDevelopmentLifecycleStages: ['concept']
+    };
+    const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+    const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+    const ref1Prop = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'object_reference',
+        slug: 'ref1',
+        label: 'Object Ref#1',
+        referencedTypeRootSlug: 'color'
+    };
+    const ref2Prop = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'object_reference',
+        slug: 'ref2',
+        label: 'Object Ref#2',
+        referencedTypeRootSlug: 'color'
+    };
+    const ref3Prop = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'object_reference',
+        slug: 'ref3',
+        label: 'Object Ref#3',
+        referencedTypeRootSlug: 'color'
+    };
+    const newData = {
+        ref1Id: 1234,
+        ref1: mockObj1234,
+        ref2Id: 2222,
+        ref2: mockObj2222,
+        ref3Id: 1234,
+        ref3: mockObj1234
+    };
+    it('mapping test', async () => {
+        const oobFunction = dc.getFlexPLMObjectData;
+        try {
+            dc.getFlexPLMObjectData = async (newData) => {
+                return newData;
+            };
+            mockGetFunction.mockClear();
+            let spyGetObjectClass = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getObjectClass')
+                .mockImplementation(async () => { return 'LCSColor'; });
+            let spyGetObjectTypePath = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getObjectTypePath')
+                .mockImplementation(async () => { return 'Color'; });
+            let spyGetMapKey = jest.spyOn(type_conversion_utils_1.TypeConversionUtils, 'getMapKey')
+                .mockImplementation(async () => { return 'LCSColor'; });
+            let spyApplyTransformMap = jest.spyOn(map_utils_1.MapUtil, 'applyTransformMap')
+                .mockImplementation(async (...args) => { return args[2]; });
+            const r1 = await dc.getObjectReferenceValue(ref1Prop, newData, true);
+            const r2 = await dc.getObjectReferenceValue(ref2Prop, newData, true);
+            expect(spyGetObjectClass).toHaveBeenCalledTimes(2);
+            expect(spyGetObjectTypePath).toHaveBeenCalledTimes(2);
+            expect(spyGetMapKey).toHaveBeenCalledTimes(2);
+            expect(spyApplyTransformMap).toHaveBeenCalledTimes(2);
+        }
+        finally {
+            dc.getFlexPLMObjectData = oobFunction;
+        }
+    });
+});
+describe('setEnumerationKeys', () => {
+    const config = {
+        apiHost: 'host',
+        userName: () => 'user',
+        password: () => 'pass',
+        urlContext: 'xxx',
+        vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+        csrfEndpoint: '/servlet/rest/security/csrf',
+        itemPreDevelopmentLifecycleStages: ['concept']
+    };
+    const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+    const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+    const enumProp = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'multi_select',
+        slug: 'flexMultiSelect',
+        label: 'Flex Multi Select',
+        options: [
+            {
+                value: 'one',
+                display: 'One'
+            },
+            {
+                value: 'two',
+                display: 'Two'
+            },
+            {
+                value: 'three',
+                display: 'Three'
+            }
+        ],
+    };
+    const enumPropNoList = {
+        id: 'cJoZQvoj7dkfCBJq',
+        propertyType: 'multi_select',
+        slug: 'flexMultiSelect',
+        label: 'Flex Multi Select',
+    };
+    it('match 1 key', () => {
+        const newData = [{ value: 'one', display: 'One' }];
+        const returnValue = dc.setEnumerationKeys(enumProp, newData, false);
+        expect(returnValue).toEqual(['one']);
+    });
+    it('match 2 key', () => {
+        const newData = [{ value: 'one', display: 'One' }, { value: 'two', display: 'Two' }];
+        const returnValue = dc.setEnumerationKeys(enumProp, newData, false);
+        expect(returnValue).toEqual(['one', 'two']);
+    });
+    it('match 1 display', () => {
+        const newData = [{ value: 'one', display: 'One' }];
+        const returnValue = dc.setEnumerationKeys(enumProp, newData, true);
+        expect(returnValue).toEqual(['one']);
+    });
+    it('match 2 display', () => {
+        const newData = [{ value: 'one', display: 'One' }, { value: 'two', display: 'Two' }];
+        const returnValue = dc.setEnumerationKeys(enumProp, newData, true);
+        expect(returnValue).toEqual(['one', 'two']);
+    });
+    it('property no list', () => {
+        const newData = [{ value: 'one', display: 'One' }, { value: 'two', display: 'Two' }];
+        const returnValue = dc.setEnumerationKeys(enumPropNoList, newData, false);
+        expect(returnValue).toEqual([]);
+    });
+});

package/lib/util/map-utils.d.ts

@@ -1,6 +1,6 @@
 import { MapFileUtil } from '@contrail/transform-data';
 export declare class MapUtil {
-    static applyTransformMap(transformMapFile: any, mapFileUtil: any, data: any, type: string, direction: string): Promise<any>;
+    static applyTransformMap(transformMapFile: any, mapFileUtil: any, data: any, mapSectionKey: string, direction: string): Promise<any>;
     static getMapKey(transformMapFile: any, mapFileUtil: MapFileUtil, data: any, type: string, direction: string): Promise<string>;
-    static getFullMapSection(transformMapFile: string, mapFileUtil: MapFileUtil, mapKey: string): Promise<any>;
+    static getFullMapSection(transformMapFile: string, mapFileUtil: MapFileUtil, mapSectionKey: string): Promise<any>;
 }

package/lib/util/map-utils.js

@@ -1,38 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MapUtil = void 0;
-const transform_data_1 = require("@contrail/transform-data");
 class MapUtil {
-    static async applyTransformMap(transformMapFile, mapFileUtil, data, type, direction) {
-        if (transformMapFile) {
-            const mapping = await mapFileUtil.getMappingSection(transformMapFile, type, direction);
-            if (mapping) {
-                const tasks = transform_data_1.MapFileUtil.getTransformTasks(mapping);
-                if (tasks.length > 0) {
-                    const convertedArray = transform_data_1.TransformProcessor.transformData([data], tasks);
-                    data = convertedArray[0];
-                }
-            }
-        }
-        return data;
+    static async applyTransformMap(transformMapFile, mapFileUtil, data, mapSectionKey, direction) {
+        return await mapFileUtil.applyTransformMap(transformMapFile, data, mapSectionKey, direction);
     }
     static async getMapKey(transformMapFile, mapFileUtil, data, type, direction) {
-        const mappingData = await mapFileUtil.getMappingSection(transformMapFile, 'typeConversion', direction);
-        if (mappingData && mappingData[type] && mappingData[type]['getMapKey']) {
-            const mapKey = await mappingData[type]['getMapKey'](data);
-            return mapKey;
-        }
-        return undefined;
+        return await mapFileUtil.getMapKey(transformMapFile, data, type, direction);
     }
-    static async getFullMapSection(transformMapFile, mapFileUtil, mapKey) {
-        if (mapKey) {
-            const mapFile = await mapFileUtil.getMapFile(transformMapFile);
-            if (mapFile) {
-                const mapSection = mapFile[mapKey];
-                return mapSection;
-            }
-        }
-        return undefined;
+    static async getFullMapSection(transformMapFile, mapFileUtil, mapSectionKey) {
+        return await mapFileUtil.getFullMapSection(transformMapFile, mapSectionKey);
     }
 }
 exports.MapUtil = MapUtil;

package/lib/util/map-utils.spec.d.ts

@@ -0,0 +1 @@
+export {};