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

package/lib/transform/identifier-conversion-spec-mockData.js

@@ -0,0 +1,444 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.mapping = {
+    typeConversion: {
+        vibe2flex: {
+            'custom-entity': {
+                getMapKey: (entity) => {
+                    const typePath = entity['typePath'];
+                    let mapKey = '';
+                    switch (typePath) {
+                        case 'custom-entity:pack':
+                            mapKey = 'packaging';
+                            break;
+                        case 'custom-entity:prefix':
+                            mapKey = 'prefix';
+                            break;
+                        case 'custom-entity:catName':
+                            mapKey = 'catName';
+                            break;
+                        case 'custom-entity:partnerOrg':
+                            mapKey = 'partnerOrg';
+                            break;
+                        case 'custom-entity:catFamily':
+                            mapKey = 'catFamily';
+                            break;
+                        case 'custom-entity:formName':
+                            mapKey = 'formName';
+                            break;
+                    }
+                    return mapKey;
+                }
+            }
+        }
+    },
+    LCSSeason: {
+        vibe2flex: {
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                seasonName: 'flexPLMSeasonName',
+                year: 'seasonYear'
+            },
+            getSoftType: () => 'Season',
+            getClass: () => 'LCSSeason'
+        },
+        flex2vibe: {
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                flexPLMSeasonName: 'seasonName',
+                seasonYear: 'year'
+            }
+        }
+    },
+    LCSProduct: {
+        vibeOwningKeys: ['itemNumber', 'lifecycleStage'],
+        vibe2flex: {
+            getClass: () => 'LCSProduct',
+            getSoftType: (entity) => {
+                const prodType = entity['prodType'];
+                let val = '';
+                switch (prodType) {
+                    case 'acc':
+                        val = 'Product\\Accesories';
+                        break;
+                    case 'app':
+                        val = 'Product\\Apparel';
+                        break;
+                    case 'eqp':
+                        val = 'Product\\Equipment';
+                        break;
+                    case 'foot':
+                        val = 'Product\\Footwear';
+                        break;
+                }
+                return val;
+            },
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }, { processor: 'VALUE_TRANSFORM', functionTransformersKey: 'valueTransform' }],
+            rekey: {
+                productName: 'name',
+                vibeIQIdentifier: 'itemNumber'
+            },
+            valueTransform: {
+                transformEx: (row) => {
+                    return row['otherProp'] + 'xxx';
+                }
+            }
+        },
+        flex2vibe: {
+            getClass: () => 'item',
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                itemNumber: 'vibeIQIdentifier',
+                name: 'productName',
+            }
+        }
+    },
+    LCSSKU: {
+        vibeOwningKeys: ['itemNumber', 'lifecycleStage'],
+        vibe2flex: {
+            getClass: () => 'LCSSKU',
+            getSoftType: (entity) => {
+                const prodType = entity['prodType'];
+                let val = '';
+                switch (prodType) {
+                    case 'acc':
+                        val = 'Product\\Accesories';
+                        break;
+                    case 'app':
+                        val = 'Product\\Apparel';
+                        break;
+                    case 'eqp':
+                        val = 'Product\\Equipment';
+                        break;
+                    case 'foot':
+                        val = 'Product\\Footwear';
+                        break;
+                }
+                return val;
+            },
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                skuName: 'optionName',
+                vibeIQIdentifier: 'itemNumber'
+            }
+        },
+        flex2vibe: {
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                itemNumber: 'vibeIQIdentifier',
+                optionName: 'skuName',
+            }
+        }
+    },
+    packaging: {
+        vibe2flex: {
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                retailPackType: 'packType',
+                retailIntroDate: 'introDate'
+            },
+            getSoftType: () => 'Revisable Entity\\packaging',
+            getClass: () => 'LCSRevisableEntity'
+        },
+        flex2vibe: {
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                packType: 'retailPackType',
+                introDate: 'retailIntroDate'
+            },
+            getClass: () => 'custom-entity',
+            getSoftType: () => 'custom-entity:pack',
+        }
+    },
+    prefix: {
+        vibe2flex: {
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                retailOwner: 'owner',
+                retailIntroDate: 'introDate'
+            },
+            getSoftType: () => 'Revisable Entity\\prefix',
+            getClass: () => 'LCSRevisableEntity'
+        },
+        flex2vibe: {
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                owner: 'retailOwner',
+                introDate: 'retailIntroDate'
+            },
+            getClass: () => 'custom-entity',
+            getSoftType: () => 'custom-entity:prefix',
+        }
+    },
+    catName: {
+        getIdentifierProperties: () => ['catName', 'catNumber'],
+        getInformationalProperties: () => ['longName'],
+        vibe2flex: {
+            transformOrder: [],
+            getSoftType: () => 'Last\\catName',
+            getClass: () => 'LCSLast'
+        },
+        flex2vibe: {
+            transformOrder: [],
+            getClass: () => 'custom-entity',
+            getSoftType: () => 'custom-entity:catName',
+        }
+    },
+    partnerOrg: {
+        vibe2flex: {
+            transformOrder: [],
+            getSoftType: () => 'Business Object\\partnerOrg',
+            getClass: () => 'LCSLifecycleManaged'
+        },
+        flex2vibe: {
+            transformOrder: [],
+            getClass: () => 'custom-entity',
+            getSoftType: () => 'custom-entity:partnerOrg',
+        }
+    },
+    catFamily: {
+        vibe2flex: {
+            transformOrder: [],
+            getSoftType: () => 'Revisable Entity\\catFamily',
+            getClass: () => 'LCSRevisableEntity'
+        },
+        flex2vibe: {
+            transformOrder: [],
+            getClass: () => 'custom-entity',
+            getSoftType: () => 'custom-entity:catFamily',
+        }
+    },
+    formName: {
+        vibe2flex: {
+            transformOrder: [],
+            getSoftType: () => 'Material\\form',
+            getClass: () => 'LCSMaterial'
+        },
+        flex2vibe: {
+            transformOrder: [],
+            getClass: () => 'custom-entity',
+            getSoftType: () => 'custom-entity:formName',
+        }
+    },
+};
+exports.mapping2 = {
+    typeConversion: {
+        vibe2flex: {
+            'custom-entity': {
+                getMapKey: (entity) => {
+                    const typePath = entity['typePath'];
+                    let mapKey = '';
+                    switch (typePath) {
+                        case 'custom-entity:pack':
+                            mapKey = 'packaging';
+                            break;
+                        case 'custom-entity:prefix':
+                            mapKey = 'prefix';
+                            break;
+                        case 'custom-entity:catName':
+                            mapKey = 'catName';
+                            break;
+                        case 'custom-entity:partnerOrg':
+                            mapKey = 'partnerOrg';
+                            break;
+                        case 'custom-entity:catFamily':
+                            mapKey = 'catFamily';
+                            break;
+                        case 'custom-entity:formName':
+                            mapKey = 'formName';
+                            break;
+                    }
+                    return mapKey;
+                }
+            }
+        }
+    },
+    LCSSeason: {
+        getIdentifierProperties: () => ['brand', 'year', 'seasonType'],
+        vibe2flex: {
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                seasonName: 'flexPLMSeasonName'
+            },
+            getSoftType: () => 'Season',
+            getClass: () => 'LCSSeason'
+        },
+        flex2vibe: {
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                flexPLMSeasonName: 'seasonName'
+            }
+        }
+    },
+    LCSProduct: {
+        vibeOwningKeys: ['itemNumber', 'lifecycleStage'],
+        vibe2flex: {
+            getClass: () => 'LCSProduct',
+            getSoftType: (entity) => {
+                const prodType = entity['prodType'];
+                let val = '';
+                switch (prodType) {
+                    case 'acc':
+                        val = 'Product\\Accesories';
+                        break;
+                    case 'app':
+                        val = 'Product\\Apparel';
+                        break;
+                    case 'eqp':
+                        val = 'Product\\Equipment';
+                        break;
+                    case 'foot':
+                        val = 'Product\\Footwear';
+                        break;
+                }
+                return val;
+            },
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }, { processor: 'VALUE_TRANSFORM', functionTransformersKey: 'valueTransform' }],
+            rekey: {
+                productName: 'name',
+                vibeIQIdentifier: 'itemNumber'
+            },
+            valueTransform: {
+                transformEx: (row) => {
+                    return row['otherProp'] + 'xxx';
+                }
+            }
+        },
+        flex2vibe: {
+            getClass: () => 'item',
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                itemNumber: 'vibeIQIdentifier',
+                name: 'productName',
+            }
+        }
+    },
+    LCSSKU: {
+        vibeOwningKeys: ['itemNumber', 'lifecycleStage'],
+        getIdentifierProperties: () => ['uniqueIdentifierA', 'uniqueIdentifierB'],
+        vibe2flex: {
+            getClass: () => 'LCSSKU',
+            getSoftType: (entity) => {
+                const prodType = entity['prodType'];
+                let val = '';
+                switch (prodType) {
+                    case 'acc':
+                        val = 'Product\\Accesories';
+                        break;
+                    case 'app':
+                        val = 'Product\\Apparel';
+                        break;
+                    case 'eqp':
+                        val = 'Product\\Equipment';
+                        break;
+                    case 'foot':
+                        val = 'Product\\Footwear';
+                        break;
+                }
+                return val;
+            },
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                skuName: 'optionName',
+                vibeIQIdentifier: 'itemNumber'
+            }
+        },
+        flex2vibe: {
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                itemNumber: 'vibeIQIdentifier',
+                optionName: 'skuName',
+            }
+        }
+    },
+    packaging: {
+        vibe2flex: {
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                retailPackType: 'packType',
+                retailIntroDate: 'introDate'
+            },
+            getSoftType: () => 'Revisable Entity\\packaging',
+            getClass: () => 'LCSRevisableEntity'
+        },
+        flex2vibe: {
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                packType: 'retailPackType',
+                introDate: 'retailIntroDate'
+            },
+            getClass: () => 'custom-entity',
+            getSoftType: () => 'custom-entity:pack',
+        }
+    },
+    prefix: {
+        vibe2flex: {
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                retailOwner: 'owner',
+                retailIntroDate: 'introDate'
+            },
+            getSoftType: () => 'Revisable Entity\\prefix',
+            getClass: () => 'LCSRevisableEntity'
+        },
+        flex2vibe: {
+            transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
+            rekey: {
+                owner: 'retailOwner',
+                introDate: 'retailIntroDate'
+            },
+            getClass: () => 'custom-entity',
+            getSoftType: () => 'custom-entity:prefix',
+        }
+    },
+    catName: {
+        getIdentifierProperties: () => ['catName', 'catNumber'],
+        getInformationalProperties: () => ['longName'],
+        vibe2flex: {
+            transformOrder: [],
+            getSoftType: () => 'Last\\catName',
+            getClass: () => 'LCSLast'
+        },
+        flex2vibe: {
+            transformOrder: [],
+            getClass: () => 'custom-entity',
+            getSoftType: () => 'custom-entity:catName',
+        }
+    },
+    partnerOrg: {
+        vibe2flex: {
+            transformOrder: [],
+            getSoftType: () => 'Business Object\\partnerOrg',
+            getClass: () => 'LCSLifecycleManaged'
+        },
+        flex2vibe: {
+            transformOrder: [],
+            getClass: () => 'custom-entity',
+            getSoftType: () => 'custom-entity:partnerOrg',
+        }
+    },
+    catFamily: {
+        vibe2flex: {
+            transformOrder: [],
+            getSoftType: () => 'Revisable Entity\\catFamily',
+            getClass: () => 'LCSRevisableEntity'
+        },
+        flex2vibe: {
+            transformOrder: [],
+            getClass: () => 'custom-entity',
+            getSoftType: () => 'custom-entity:catFamily',
+        }
+    },
+    formName: {
+        vibe2flex: {
+            transformOrder: [],
+            getSoftType: () => 'Material\\form',
+            getClass: () => 'LCSMaterial'
+        },
+        flex2vibe: {
+            transformOrder: [],
+            getClass: () => 'custom-entity',
+            getSoftType: () => 'custom-entity:formName',
+        }
+    },
+};

package/lib/transform/identifier-conversion.d.ts

@@ -0,0 +1,15 @@
+import { MapFileUtil } from "@contrail/transform-data";
+import { ProductFederation, SeasonFederation, SeasonGroupFederation, SkuFederation } from "../interfaces/interfaces";
+import { DataConverter } from "../util/data-converter";
+export declare class IdentifierConversion {
+    static readonly INBOUND_ENTITY_MISSING_IDENIFIER_PROPS = "IdentifierConversion.getEntityCriteriaFromObject(): missing identifier properties: ";
+    static readonly MISSING_OBJECT = "IdentifierConversion.getEntityCriteriaFromObject(): missing: object";
+    static readonly MISSING_FLEXPLM_OBJECT_CLASS = "IdentifierConversion.getEntityCriteriaFromObject(): missing: flexPLMObjectClass";
+    static getSeasonIdentityObject(transformMapFile: string, mapFileUtil: MapFileUtil, dc: DataConverter, assortment: any, includeInformationKeys?: boolean): Promise<SeasonFederation>;
+    static getSeasonGroupIdentityObject(transformMapFile: string, mapFileUtil: MapFileUtil, dc: DataConverter, assortment: any, includeInformationKeys?: boolean): Promise<SeasonGroupFederation>;
+    static getProductIdentityObject(transformMapFile: string, mapFileUtil: MapFileUtil, dc: DataConverter, itemFamilyObject: any, includeInformationKeys?: boolean): Promise<ProductFederation>;
+    static getSKUIdentityObject(transformMapFile: string, mapFileUtil: MapFileUtil, dc: DataConverter, itemObject: any, includeInformationKeys?: boolean): Promise<SkuFederation>;
+    static getEntityCriteriaFromObject(transformMapFile: string, mapFileUtil: MapFileUtil, dc: DataConverter, object: any): Promise<any>;
+    static getAssortmentCriteriaFromObject(transformMapFile: string, mapFileUtil: MapFileUtil, dc: DataConverter, object: any): Promise<any>;
+    static getItemCriteriaFromObject(transformMapFile: string, mapFileUtil: MapFileUtil, dc: DataConverter, object: any): Promise<any>;
+}

package/lib/transform/identifier-conversion.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentifierConversion = void 0;
+const map_utils_1 = require("../util/map-utils");
+const type_conversion_utils_1 = require("../util/type-conversion-utils");
+const event_short_message_status_1 = require("../util/event-short-message-status");
+class IdentifierConversion {
+    static async getSeasonIdentityObject(transformMapFile, mapFileUtil, dc, assortment, includeInformationKeys = true) {
+        if (!assortment) {
+            throw new Error('IdentifierConversion.getSeasonIdentityObject(): assortment must be provided.');
+        }
+        assortment['flex2vibeMapKeyRoot'] = 'LCSSeason';
+        const flexPLMTypePath = await type_conversion_utils_1.TypeConversionUtils.getObjectTypePath(transformMapFile, mapFileUtil, assortment);
+        let seasonObj = {
+            entityReference: 'assortment:' + assortment?.id,
+            objectClass: 'LCSSeason',
+            flexPLMTypePath
+        };
+        try {
+            const assortmentObj = await dc.getFlexPLMObjectData(assortment, [], true);
+            const identifierKeys = await type_conversion_utils_1.TypeConversionUtils.getIdentifierProperties(transformMapFile, mapFileUtil, assortment);
+            for (const key of identifierKeys) {
+                if (assortmentObj[key]) {
+                    seasonObj[key] = assortmentObj[key];
+                }
+            }
+            if (includeInformationKeys) {
+                const informationKeys = await type_conversion_utils_1.TypeConversionUtils
+                    .getInformationalProperties(transformMapFile, mapFileUtil, assortment);
+                for (const key of informationKeys) {
+                    if (assortmentObj[key]) {
+                        seasonObj[key] = assortmentObj[key];
+                    }
+                }
+            }
+            const objectKeys = Object.keys(seasonObj);
+            const hasAllIdentifiers = identifierKeys.every(key => objectKeys.includes(key));
+            if (!hasAllIdentifiers) {
+                console.error('IdentifierConversion.getSeasonIdentityObject(): doesnt have all identifier properties - ' + identifierKeys);
+                console.error('assortment: ' + JSON.stringify(assortment));
+            }
+            const mapKey = await type_conversion_utils_1.TypeConversionUtils
+                .getMapKey(transformMapFile, mapFileUtil, assortment, type_conversion_utils_1.TypeConversionUtils.VIBE2FLEX_DIRECTION);
+            seasonObj = await map_utils_1.MapUtil
+                .applyTransformMap(transformMapFile, mapFileUtil, seasonObj, mapKey, type_conversion_utils_1.TypeConversionUtils.VIBE2FLEX_DIRECTION);
+        }
+        finally {
+            delete assortment['flex2vibeMapKeyRoot'];
+        }
+        return seasonObj;
+    }
+    static async getSeasonGroupIdentityObject(transformMapFile, mapFileUtil, dc, assortment, includeInformationKeys = true) {
+        if (!assortment) {
+            throw new Error('IdentifierConversion.getSeasonGroupIdentityObject(): assortment must be provided.');
+        }
+        assortment['flex2vibeMapKeyRoot'] = 'SeasonGroup';
+        const flexPLMTypePath = await type_conversion_utils_1.TypeConversionUtils.getObjectTypePath(transformMapFile, mapFileUtil, assortment);
+        let seasonGroupObj = {
+            entityReference: 'assortment:' + assortment?.id,
+            objectClass: 'SeasonGroup',
+            flexPLMTypePath
+        };
+        try {
+            const assortmentObj = await dc.getFlexPLMObjectData(assortment, [], true);
+            const identifierKeys = await type_conversion_utils_1.TypeConversionUtils
+                .getIdentifierProperties(transformMapFile, mapFileUtil, assortment);
+            for (const key of identifierKeys) {
+                if (assortmentObj[key]) {
+                    seasonGroupObj[key] = assortmentObj[key];
+                }
+            }
+            if (includeInformationKeys) {
+                const informationKeys = await type_conversion_utils_1.TypeConversionUtils
+                    .getInformationalProperties(transformMapFile, mapFileUtil, assortment);
+                for (const key of informationKeys) {
+                    if (assortmentObj[key]) {
+                        seasonGroupObj[key] = assortmentObj[key];
+                    }
+                }
+            }
+            const objectKeys = Object.keys(seasonGroupObj);
+            const hasAllIdentifiers = identifierKeys.every(key => objectKeys.includes(key));
+            if (!hasAllIdentifiers) {
+                console.error('IdentifierConversion.getSeasonGroupIdentityObject(): doesnt have all identifier properties - ' + identifierKeys);
+                console.error('assortment: ' + JSON.stringify(assortment));
+            }
+            const mapKey = await type_conversion_utils_1.TypeConversionUtils.getMapKey(transformMapFile, mapFileUtil, assortment, type_conversion_utils_1.TypeConversionUtils.VIBE2FLEX_DIRECTION);
+            seasonGroupObj = await map_utils_1.MapUtil.applyTransformMap(transformMapFile, mapFileUtil, seasonGroupObj, mapKey, type_conversion_utils_1.TypeConversionUtils.VIBE2FLEX_DIRECTION);
+        }
+        finally {
+            delete assortment['flex2vibeMapKeyRoot'];
+        }
+        return seasonGroupObj;
+    }
+    static async getProductIdentityObject(transformMapFile, mapFileUtil, dc, itemFamilyObject, includeInformationKeys = true) {
+        if (!itemFamilyObject) {
+            throw new Error('IdentifierConversion.getProductIdentityObject(): itemFamilyObject must be provided.');
+        }
+        const itemObj = await dc.getFlexPLMObjectData(itemFamilyObject, [], true);
+        const flexPLMTypePath = await type_conversion_utils_1.TypeConversionUtils.getObjectTypePath(transformMapFile, mapFileUtil, itemFamilyObject);
+        let prodObj = {
+            entityReference: 'item:' + itemFamilyObject?.id,
+            objectClass: 'LCSProduct',
+            flexPLMTypePath
+        };
+        const identifierKeys = await type_conversion_utils_1.TypeConversionUtils
+            .getIdentifierProperties(transformMapFile, mapFileUtil, itemFamilyObject);
+        for (const key of identifierKeys) {
+            if (itemObj[key]) {
+                prodObj[key] = itemObj[key];
+            }
+        }
+        if (includeInformationKeys) {
+            const informationKeys = await type_conversion_utils_1.TypeConversionUtils
+                .getInformationalProperties(transformMapFile, mapFileUtil, itemFamilyObject);
+            for (const key of informationKeys) {
+                if (itemObj[key]) {
+                    prodObj[key] = itemObj[key];
+                }
+            }
+        }
+        const vibeIQIdentifier = 'vibeIQIdentifier';
+        if (!prodObj[vibeIQIdentifier]) {
+            prodObj['vibeIQIdentifier'] = itemFamilyObject['identifier'] || itemFamilyObject['itemNumber'];
+        }
+        const mapKey = await type_conversion_utils_1.TypeConversionUtils
+            .getMapKey(transformMapFile, mapFileUtil, itemFamilyObject, type_conversion_utils_1.TypeConversionUtils.VIBE2FLEX_DIRECTION);
+        prodObj = await map_utils_1.MapUtil
+            .applyTransformMap(transformMapFile, mapFileUtil, prodObj, mapKey, type_conversion_utils_1.TypeConversionUtils.VIBE2FLEX_DIRECTION);
+        return prodObj;
+    }
+    static async getSKUIdentityObject(transformMapFile, mapFileUtil, dc, itemObject, includeInformationKeys = true) {
+        if (!itemObject) {
+            throw new Error('IdentifierConversion.getSKUIdentityObject(): itemObject must be provided.');
+        }
+        const itemObj = await dc.getFlexPLMObjectData(itemObject, [], true);
+        const flexPLMTypePath = await type_conversion_utils_1.TypeConversionUtils.getObjectTypePath(transformMapFile, mapFileUtil, itemObject);
+        let skuObj = {
+            entityReference: 'item:' + itemObject?.id,
+            objectClass: 'LCSSKU',
+            flexPLMTypePath
+        };
+        const identifierKeys = await type_conversion_utils_1.TypeConversionUtils.getIdentifierProperties(transformMapFile, mapFileUtil, itemObject);
+        for (const key of identifierKeys) {
+            if (itemObj[key]) {
+                skuObj[key] = itemObj[key];
+            }
+        }
+        if (includeInformationKeys) {
+            const informationKeys = await type_conversion_utils_1.TypeConversionUtils.getInformationalProperties(transformMapFile, mapFileUtil, itemObject);
+            for (const key of informationKeys) {
+                if (itemObj[key]) {
+                    skuObj[key] = itemObj[key];
+                }
+            }
+        }
+        const vibeIQIdentifier = 'vibeIQIdentifier';
+        if (!skuObj[vibeIQIdentifier]) {
+            skuObj['vibeIQIdentifier'] = itemObject['identifier'] || itemObject['itemNumber'];
+        }
+        const mapKey = await type_conversion_utils_1.TypeConversionUtils.getMapKey(transformMapFile, mapFileUtil, itemObject, type_conversion_utils_1.TypeConversionUtils.VIBE2FLEX_DIRECTION);
+        skuObj = await map_utils_1.MapUtil.applyTransformMap(transformMapFile, mapFileUtil, skuObj, mapKey, type_conversion_utils_1.TypeConversionUtils.VIBE2FLEX_DIRECTION);
+        return skuObj;
+    }
+    static async getEntityCriteriaFromObject(transformMapFile, mapFileUtil, dc, object) {
+        if (!object) {
+            const e = new Error(IdentifierConversion.MISSING_OBJECT);
+            e['shortStatusMessage'] = event_short_message_status_1.EventShortMessageStatus.MISSING_INPUT;
+            throw e;
+        }
+        else if (!object.flexPLMObjectClass) {
+            const e = new Error(IdentifierConversion.MISSING_FLEXPLM_OBJECT_CLASS);
+            e['shortStatusMessage'] = event_short_message_status_1.EventShortMessageStatus.MISSING_INPUT;
+            throw e;
+        }
+        const mapKey = await type_conversion_utils_1.TypeConversionUtils.getMapKeyFromObject(transformMapFile, mapFileUtil, object, type_conversion_utils_1.TypeConversionUtils.FLEX2VIBE_DIRECTION);
+        const identifierKeys = await type_conversion_utils_1.TypeConversionUtils.getIdentifierPropertiesFromObject(transformMapFile, mapFileUtil, object);
+        const objectData = await map_utils_1.MapUtil.applyTransformMap(transformMapFile, mapFileUtil, object, mapKey, type_conversion_utils_1.TypeConversionUtils.FLEX2VIBE_DIRECTION);
+        let identifierValues = identifierKeys.reduce((acc, key) => {
+            acc[key] = objectData[key];
+            return acc;
+        }, {});
+        identifierValues['flexPLMObjectClass'] = objectData?.flexPLMObjectClass;
+        identifierValues['flexPLMTypePath'] = objectData?.flexPLMTypePath;
+        identifierValues = await dc.getEntityValues(objectData?.flexPLMObjectClass, identifierValues, []);
+        const entityKeys = Object.keys(identifierValues);
+        const hasAllIdentifiers = identifierKeys.every(key => entityKeys.includes(key));
+        if (!hasAllIdentifiers) {
+            const e = new Error(IdentifierConversion.INBOUND_ENTITY_MISSING_IDENIFIER_PROPS + identifierKeys);
+            e['shortStatusMessage'] = event_short_message_status_1.EventShortMessageStatus.MISSING_IDENTIFIER_PROPERTIES;
+            throw e;
+        }
+        const criteria = {};
+        for (const key of identifierKeys) {
+            criteria[key] = identifierValues[key];
+        }
+        return criteria;
+    }
+    static async getAssortmentCriteriaFromObject(transformMapFile, mapFileUtil, dc, object) {
+        return IdentifierConversion.getEntityCriteriaFromObject(transformMapFile, mapFileUtil, dc, object);
+    }
+    static async getItemCriteriaFromObject(transformMapFile, mapFileUtil, dc, object) {
+        const criteria = await IdentifierConversion.getEntityCriteriaFromObject(transformMapFile, mapFileUtil, dc, object);
+        const roles = (object.flexPLMObjectClass === 'LCSProduct') ? 'family' : 'color';
+        criteria['roles'] = roles;
+        return criteria;
+    }
+}
+exports.IdentifierConversion = IdentifierConversion;
+IdentifierConversion.INBOUND_ENTITY_MISSING_IDENIFIER_PROPS = 'IdentifierConversion.getEntityCriteriaFromObject(): missing identifier properties: ';
+IdentifierConversion.MISSING_OBJECT = 'IdentifierConversion.getEntityCriteriaFromObject(): missing: object';
+IdentifierConversion.MISSING_FLEXPLM_OBJECT_CLASS = 'IdentifierConversion.getEntityCriteriaFromObject(): missing: flexPLMObjectClass';

package/lib/transform/identifier-conversion.spec.d.ts

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