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

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

@@ -0,0 +1,259 @@
+'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;
+                }
+            }
+        },
+        flex2vibe: {
+            LCSLast: {
+                getMapKey: (object) => { return 'catName'; }
+            },
+            LCSRevisableEntity: {
+                getMapKey: (object) => {
+                    const typePath = object['flexPLMTypePath'];
+                    let mapKey = '';
+                    switch (typePath) {
+                        case 'Revisable Entity\\packaging':
+                            mapKey = 'packaging';
+                            break;
+                        case 'Revisable Entity\\prefix':
+                            mapKey = 'prefix';
+                            break;
+                    }
+                    ;
+                    return mapKey;
+                }
+            }
+        }
+    },
+    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: {
+        isOutboundCreatable: (entity, context) => {
+            return false;
+        },
+        syncInboundImages: (entity, context) => {
+            return true;
+        },
+        syncOutboundImages: (entity, context) => {
+            return false;
+        },
+        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: {
+        isInboundCreatable: (object, context) => {
+            if (context && context.skipPrefix) {
+                return false;
+            }
+            return true;
+        },
+        isOutboundCreatable: (entity, context) => {
+            if (context && context.skipPrefix) {
+                return false;
+            }
+            return true;
+        },
+        syncInboundImages: (entity, context) => {
+            if (context && context.skipImages) {
+                return false;
+            }
+            return true;
+        },
+        syncOutboundImages: (entity, context) => {
+            if (context && context.skipImages) {
+                return false;
+            }
+            return true;
+        },
+        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/util/type-conversion-utils.d.ts

@@ -0,0 +1,23 @@
+import { MapFileUtil } from '@contrail/transform-data';
+export declare class TypeConversionUtils {
+    static NO_ENTITY_TYPE: string;
+    static VIBE2FLEX_DIRECTION: string;
+    static FLEX2VIBE_DIRECTION: string;
+    constructor();
+    static getObjectClass(transformMapFile: any, mapFileUtil: any, entity: any): Promise<string>;
+    static getObjectTypePath(transformMapFile: any, mapFileUtil: any, entity: any): Promise<string>;
+    static getIdentifierProperties(transformMapFile: any, mapFileUtil: any, entity: any): Promise<string[]>;
+    static getInformationalProperties(transformMapFile: any, mapFileUtil: any, entity: any): Promise<string[]>;
+    static getMapKey(transformMapFile: any, mapFileUtil: MapFileUtil, entity: any, direction: string): Promise<string>;
+    static getEntityType(entity: any): any;
+    static getEntityClassFromObject(fileId: any, mapFileUtil: any, object: any): Promise<string>;
+    static getEntityTypePathFromOjbect(fileId: any, mapFileUtil: any, object: any): Promise<string>;
+    static getIdentifierPropertiesFromObject(fileId: any, mapFileUtil: MapFileUtil, object: any): Promise<string[]>;
+    static getInformationalPropertiesFromObject(fileId: any, mapFileUtil: MapFileUtil, object: any): Promise<string[]>;
+    static getMapKeyFromObject(fileId: any, mapFileUtil: MapFileUtil, object: any, direction: string): Promise<string>;
+    static isInboundCreatableFromObject(fileId: string, mapFileUtil: MapFileUtil, object: any, context?: any): Promise<boolean>;
+    static isOutboundCreatableFromEntity(fileId: string, mapFileUtil: MapFileUtil, entity: any, context?: any): Promise<boolean>;
+    static syncInboundImages(fileId: string, mapFileUtil: MapFileUtil, object: any, context?: any): Promise<boolean>;
+    static syncOutboundImages(fileId: string, mapFileUtil: MapFileUtil, entity: any, context?: any): Promise<boolean>;
+    static getObjectType(object: any): any;
+}

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

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeConversionUtils = void 0;
+const type_defaults_1 = require("./type-defaults");
+const map_utils_1 = require("./map-utils");
+class TypeConversionUtils {
+    constructor() {
+    }
+    static async getObjectClass(transformMapFile, mapFileUtil, entity) {
+        let objectClass = entity['flexPLMObjectClass'];
+        if (objectClass) {
+            return objectClass;
+        }
+        if (transformMapFile) {
+            const mapSectionKey = await this.getMapKey(transformMapFile, mapFileUtil, entity, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+            const mapData = await mapFileUtil.getMappingSection(transformMapFile, mapSectionKey, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+            if (mapData['getClass']) {
+                objectClass = await mapData['getClass'](entity);
+            }
+        }
+        if (objectClass) {
+            return objectClass;
+        }
+        return type_defaults_1.TypeDefaults.getDefaultObjectClass(entity);
+    }
+    static async getObjectTypePath(transformMapFile, mapFileUtil, entity) {
+        let typePath = entity['flexPLMTypePath'];
+        if (typePath) {
+            return typePath;
+        }
+        if (transformMapFile) {
+            const mapSectionKey = await this.getMapKey(transformMapFile, mapFileUtil, entity, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+            const mapData = await mapFileUtil.getMappingSection(transformMapFile, mapSectionKey, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+            if (mapData['getSoftType']) {
+                typePath = await mapData['getSoftType'](entity);
+            }
+        }
+        if (typePath) {
+            return typePath;
+        }
+        return type_defaults_1.TypeDefaults.getDefaultObjectTypePath(entity);
+    }
+    static async getIdentifierProperties(transformMapFile, mapFileUtil, entity) {
+        let identifiers = entity['flexPLMIdentifierProperties'];
+        if (identifiers) {
+            return identifiers;
+        }
+        if (transformMapFile) {
+            const mapKey = await this.getMapKey(transformMapFile, mapFileUtil, entity, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+            const mapData = await map_utils_1.MapUtil.getFullMapSection(transformMapFile, mapFileUtil, mapKey);
+            if (mapData && mapData['getIdentifierProperties']) {
+                identifiers = await mapData['getIdentifierProperties'](entity);
+            }
+        }
+        if (identifiers) {
+            return identifiers;
+        }
+        return type_defaults_1.TypeDefaults.getDefaultIdentifierProperties(entity);
+    }
+    static async getInformationalProperties(transformMapFile, mapFileUtil, entity) {
+        let identifiers = entity['flexPLMInformationalProperties'];
+        if (identifiers) {
+            return identifiers;
+        }
+        if (transformMapFile) {
+            const mapKey = await this.getMapKey(transformMapFile, mapFileUtil, entity, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+            const mapData = await map_utils_1.MapUtil.getFullMapSection(transformMapFile, mapFileUtil, mapKey);
+            if (mapData && mapData['getInformationalProperties']) {
+                identifiers = await mapData['getInformationalProperties'](entity);
+            }
+        }
+        if (identifiers) {
+            return identifiers;
+        }
+        return type_defaults_1.TypeDefaults.getDefaultInformationalProperties(entity);
+    }
+    static async getMapKey(transformMapFile, mapFileUtil, entity, direction) {
+        if (transformMapFile) {
+            const type = this.getEntityType(entity);
+            const mappingData = await mapFileUtil.getMappingSection(transformMapFile, 'typeConversion', direction);
+            if (mappingData && mappingData[type] && mappingData[type]['getMapKey']) {
+                const mapKey = await mappingData[type]['getMapKey'](entity);
+                return mapKey;
+            }
+        }
+        return type_defaults_1.TypeDefaults.getDefaultObjectClass(entity);
+    }
+    static getEntityType(entity) {
+        let entityType = entity['entityType'];
+        if (!entityType) {
+            const typePath = entity['typePath'];
+            if (typePath) {
+                const types = typePath.split(':');
+                if (types && types[0]) {
+                    entityType = types[0];
+                }
+            }
+        }
+        if (!entityType) {
+            throw Error(TypeConversionUtils.NO_ENTITY_TYPE);
+        }
+        return entityType;
+    }
+    static async getEntityClassFromObject(fileId, mapFileUtil, object) {
+        let entityClass = object['vibeIQEntityClass'];
+        if (entityClass) {
+            return entityClass;
+        }
+        if (fileId) {
+            const mapSectionKey = await this.getMapKeyFromObject(fileId, mapFileUtil, object, TypeConversionUtils.FLEX2VIBE_DIRECTION);
+            const mapData = await mapFileUtil.getMappingSection(fileId, mapSectionKey, TypeConversionUtils.FLEX2VIBE_DIRECTION);
+            if (mapData['getClass']) {
+                entityClass = await mapData['getClass'](object);
+            }
+        }
+        if (entityClass) {
+            return entityClass;
+        }
+        return type_defaults_1.TypeDefaults.getDefaultEntityClass(object);
+    }
+    static async getEntityTypePathFromOjbect(fileId, mapFileUtil, object) {
+        let typePath = object['vibeIQTypePath'];
+        if (typePath) {
+            return typePath;
+        }
+        if (fileId) {
+            const mapSectionKey = await this.getMapKeyFromObject(fileId, mapFileUtil, object, TypeConversionUtils.FLEX2VIBE_DIRECTION);
+            const mapData = await mapFileUtil.getMappingSection(fileId, mapSectionKey, TypeConversionUtils.FLEX2VIBE_DIRECTION);
+            if (mapData['getSoftType']) {
+                typePath = await mapData['getSoftType'](object);
+            }
+        }
+        if (typePath) {
+            return typePath;
+        }
+        return type_defaults_1.TypeDefaults.getDefaultEntityTypePath(object);
+    }
+    static async getIdentifierPropertiesFromObject(fileId, mapFileUtil, object) {
+        let identifiers = object['vibeIQIdentifierProperties'];
+        if (identifiers) {
+            return identifiers;
+        }
+        if (fileId) {
+            const mapKey = await this.getMapKeyFromObject(fileId, mapFileUtil, object, TypeConversionUtils.FLEX2VIBE_DIRECTION);
+            const mapData = await map_utils_1.MapUtil.getFullMapSection(fileId, mapFileUtil, mapKey);
+            if (mapData && mapData['getIdentifierProperties']) {
+                identifiers = await mapData['getIdentifierProperties'](object);
+            }
+        }
+        if (identifiers) {
+            return identifiers;
+        }
+        return type_defaults_1.TypeDefaults.getDefaultIdentifierPropertiesFromObject(object);
+    }
+    static async getInformationalPropertiesFromObject(fileId, mapFileUtil, object) {
+        let identifiers = object['vibeIQInformationalProperties'];
+        if (identifiers) {
+            return identifiers;
+        }
+        if (fileId) {
+            const mapKey = await this.getMapKeyFromObject(fileId, mapFileUtil, object, TypeConversionUtils.FLEX2VIBE_DIRECTION);
+            const mapData = await map_utils_1.MapUtil.getFullMapSection(fileId, mapFileUtil, mapKey);
+            if (mapData && mapData['getInformationalProperties']) {
+                identifiers = await mapData['getInformationalProperties'](object);
+            }
+        }
+        if (identifiers) {
+            return identifiers;
+        }
+        return type_defaults_1.TypeDefaults.getDefaultInformationalPropertiesFromObject(object);
+    }
+    static async getMapKeyFromObject(fileId, mapFileUtil, object, direction) {
+        const type = this.getObjectType(object);
+        if (fileId) {
+            const mappingData = await mapFileUtil.getMappingSection(fileId, 'typeConversion', direction);
+            if (mappingData && mappingData[type] && mappingData[type]['getMapKey']) {
+                const mapKey = await mappingData[type]['getMapKey'](object);
+                return mapKey;
+            }
+            return type;
+        }
+        return '';
+    }
+    static async isInboundCreatableFromObject(fileId, mapFileUtil, object, context) {
+        let isInboundCreatable = false;
+        if (fileId) {
+            const mapKey = await this.getMapKeyFromObject(fileId, mapFileUtil, object, TypeConversionUtils.FLEX2VIBE_DIRECTION);
+            const mapData = await map_utils_1.MapUtil.getFullMapSection(fileId, mapFileUtil, mapKey);
+            if (mapData && mapData['isInboundCreatable']) {
+                isInboundCreatable = await mapData['isInboundCreatable'](object, context);
+            }
+        }
+        return isInboundCreatable;
+    }
+    static async isOutboundCreatableFromEntity(fileId, mapFileUtil, entity, context) {
+        let isOutboundCreatable = true;
+        if (!fileId) {
+            return isOutboundCreatable;
+        }
+        let mapKey;
+        try {
+            mapKey = await this.getMapKey(fileId, mapFileUtil, entity, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+        }
+        catch {
+            return isOutboundCreatable;
+        }
+        if (!mapKey) {
+            return isOutboundCreatable;
+        }
+        const mapData = await map_utils_1.MapUtil.getFullMapSection(fileId, mapFileUtil, mapKey);
+        if (mapData && mapData['isOutboundCreatable']) {
+            isOutboundCreatable = await mapData['isOutboundCreatable'](entity, context);
+        }
+        return isOutboundCreatable;
+    }
+    static async syncInboundImages(fileId, mapFileUtil, object, context) {
+        let syncImages = false;
+        if (!fileId) {
+            return syncImages;
+        }
+        let mapKey;
+        try {
+            mapKey = await this.getMapKeyFromObject(fileId, mapFileUtil, object, TypeConversionUtils.FLEX2VIBE_DIRECTION);
+        }
+        catch {
+            return syncImages;
+        }
+        if (!mapKey) {
+            return syncImages;
+        }
+        const mapData = await map_utils_1.MapUtil.getFullMapSection(fileId, mapFileUtil, mapKey);
+        if (mapData && mapData['syncInboundImages']) {
+            syncImages = await mapData['syncInboundImages'](object, context);
+        }
+        return syncImages;
+    }
+    static async syncOutboundImages(fileId, mapFileUtil, entity, context) {
+        let syncImages = true;
+        if (!fileId) {
+            return syncImages;
+        }
+        let mapKey;
+        try {
+            mapKey = await this.getMapKey(fileId, mapFileUtil, entity, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+        }
+        catch {
+            return syncImages;
+        }
+        if (!mapKey) {
+            return syncImages;
+        }
+        const mapData = await map_utils_1.MapUtil.getFullMapSection(fileId, mapFileUtil, mapKey);
+        if (mapData && mapData['syncOutboundImages']) {
+            syncImages = await mapData['syncOutboundImages'](entity, context);
+        }
+        return syncImages;
+    }
+    static getObjectType(object) {
+        let objectType = object['flexPLMObjectClass'];
+        return objectType;
+    }
+}
+exports.TypeConversionUtils = TypeConversionUtils;
+TypeConversionUtils.NO_ENTITY_TYPE = 'Not able to determine the entity type of the entity object';
+TypeConversionUtils.VIBE2FLEX_DIRECTION = 'vibe2flex';
+TypeConversionUtils.FLEX2VIBE_DIRECTION = 'flex2vibe';

package/lib/util/type-conversion-utils.spec.d.ts

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