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

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

@@ -1,444 +0,0 @@
-'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

@@ -1,15 +0,0 @@
-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

@@ -1,212 +0,0 @@
-"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

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