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

package/lib/util/data-converter.js

@@ -0,0 +1,592 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataConverter = void 0;
+const sdk_1 = require("@contrail/sdk");
+const type_utils_1 = require("./type-utils");
+const app_framework_1 = require("@contrail/app-framework");
+const util_1 = require("@contrail/util");
+const type_conversion_utils_1 = require("./type-conversion-utils");
+const map_utils_1 = require("./map-utils");
+class DataConverter {
+    static clearStaticUserCache() {
+        DataConverter.staticUserCache = {};
+    }
+    static getFromStaticCache(id) {
+        return DataConverter.staticUserCache[id];
+    }
+    static setToStaticCache(id, value) {
+        DataConverter.staticUserCache[id] = value;
+    }
+    constructor(config, mapFileUtil) {
+        this.config = config;
+        this.mapFileUtil = mapFileUtil;
+        this.useDisplayForEnumerationMatching = false;
+        this.verboseDebug = false;
+        this.objRefCache = {};
+        this.userRefCache = {};
+        this.typeUtils = new type_utils_1.TypeUtils();
+        this.transformMapFile = this.config['transformMapFile'];
+        this.useDisplayForEnumerationMatching = this.config['dataConverter']
+            && this.config['dataConverter']['useDisplayForEnumerationMatching'];
+        this.verboseDebug = this.config['dataConverter']
+            && this.config['dataConverter']['verboseDebug'];
+    }
+    setVerboseDebug(val = false) {
+        this.verboseDebug = val;
+    }
+    isVerboseDebugOn() {
+        return this.verboseDebug && app_framework_1.Logger.isDebugOn();
+    }
+    async getFlexPLMObjectDataFromEvent(event, dataToSkip) {
+        return this.getFlexPLMObjectData(event.newData, dataToSkip, true);
+    }
+    async getFlexPLMObjectData(newData, dataToSkip, inflateObjRef) {
+        if (this.isVerboseDebugOn()) {
+            console.debug('newData: ' + JSON.stringify(newData));
+        }
+        dataToSkip = dataToSkip.concat(['updatedOn', 'updatedById', 'createdOn', 'createdById', 'modifiedAt', 'orgId', 'createdAt', 'id', 'typeId', 'workspaceId']);
+        const data = {};
+        const typeId = newData?.typeId;
+        if (!typeId) {
+            return;
+        }
+        data['typePath'] = newData['typePath'];
+        const type = await this.typeUtils.getTypeById(typeId);
+        const typeProps = this.typeUtils.filterTypeProperties(type, newData);
+        for (const prop of typeProps) {
+            const slug = prop['slug'];
+            if (dataToSkip.includes(slug)) {
+                continue;
+            }
+            data[slug] = await this.getFlexPLMValue(prop, newData, inflateObjRef);
+        }
+        if (this.isVerboseDebugOn()) {
+            console.debug('getFlexPLMObjectData-data:  ' + JSON.stringify(data));
+        }
+        return data;
+    }
+    async getFlexPLMValue(prop, newData, inflateObjRef) {
+        const propertyType = prop['propertyType'];
+        const slug = prop['slug'];
+        const nd = newData[slug];
+        let value;
+        if (['string', 'text'].includes(propertyType)) {
+            value = nd || '';
+        }
+        else if (['number', 'currency', 'percent', 'sequence'].includes(propertyType)) {
+            value = nd || 0;
+        }
+        else if ('date' === propertyType) {
+            if (nd) {
+                value = nd;
+            }
+            else {
+                value = null;
+            }
+        }
+        else if ('boolean' === propertyType) {
+            value = (nd) ? true : false;
+        }
+        else if ('choice' === propertyType) {
+            value = this.getEnumerationValue(prop, nd);
+        }
+        else if ('multi_select' === propertyType) {
+            value = this.getEnumerationValue(prop, nd);
+        }
+        else if ('object_reference' === propertyType) {
+            value = await this.getObjectReferenceValue(prop, newData, inflateObjRef);
+            if (this.isVerboseDebugOn()) {
+                console.debug('object_reference: ' + JSON.stringify(value));
+            }
+        }
+        else if ('image' === propertyType) {
+        }
+        else if ('formula' === propertyType) {
+            value = nd;
+        }
+        else if ('json' === propertyType) {
+            value = nd;
+        }
+        else if ('userList' === propertyType) {
+            value = await this.getUserListValue(prop, newData);
+        }
+        return value;
+    }
+    getEnumerationValue(prop, nd) {
+        const propertyType = prop['propertyType'];
+        let value;
+        if (['choice', 'multi_select'].includes(propertyType)) {
+            const options = prop['options'] || [];
+            if ('choice' === propertyType) {
+                if (nd) {
+                    const option = options.find(option => option.value == nd);
+                    if (option) {
+                        value = Object.assign({}, option);
+                    }
+                }
+                if (!value) {
+                    value = {};
+                }
+            }
+            else if ('multi_select' === propertyType) {
+                value = [];
+                if (nd instanceof Array) {
+                    nd.forEach(key => {
+                        const optionObject = options.find(option => option.value == key);
+                        if (optionObject) {
+                            const option = Object.assign({}, optionObject);
+                            value.push(option);
+                        }
+                    });
+                }
+                else if (typeof nd === 'string' && '' !== nd) {
+                    const optionObject = options.find(option => option.value == nd);
+                    if (optionObject) {
+                        const option = Object.assign({}, optionObject);
+                        value.push(option);
+                    }
+                }
+            }
+        }
+        return value;
+    }
+    async getObjectReferenceValue(prop, newData, inflateObjRef = false) {
+        const slug = prop['slug'];
+        if (app_framework_1.Logger.isDebugOn()) {
+            console.debug('getObjectReferenceValue-prop: ' + slug);
+        }
+        let value = newData[slug];
+        const entityType = prop['referencedTypeRootSlug'];
+        const entityId = newData[slug + 'Id'];
+        if ((!value || typeof value === 'string') && inflateObjRef) {
+            if (entityId) {
+                if (this.objRefCache[entityId]) {
+                    if (app_framework_1.Logger.isDebugOn()) {
+                        console.debug('cache hit: ' + entityId);
+                    }
+                    return this.objRefCache[entityId];
+                }
+                const criteria = {
+                    id: entityId
+                };
+                const entities = await new sdk_1.Entities().get({
+                    entityName: entityType,
+                    criteria
+                });
+                value = (entities && entities[0]) ? entities[0] : undefined;
+            }
+        }
+        if (value && !(typeof value === 'string')) {
+            const unprocessedValue = value;
+            const objectClass = await type_conversion_utils_1.TypeConversionUtils.getObjectClass(this.transformMapFile, this.mapFileUtil, unprocessedValue);
+            const flexPLMTypePath = await type_conversion_utils_1.TypeConversionUtils.getObjectTypePath(this.transformMapFile, this.mapFileUtil, unprocessedValue);
+            value = await this.getFlexPLMObjectData(value, [], false);
+            value['entityReference'] = entityType + ':' + entityId;
+            value['objectClass'] = objectClass;
+            value['flexPLMTypePath'] = flexPLMTypePath;
+            if (this.transformMapFile) {
+                const mapKey = await type_conversion_utils_1.TypeConversionUtils.getMapKey(this.transformMapFile, this.mapFileUtil, unprocessedValue, type_conversion_utils_1.TypeConversionUtils.VIBE2FLEX_DIRECTION);
+                value = await map_utils_1.MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, value, mapKey, type_conversion_utils_1.TypeConversionUtils.VIBE2FLEX_DIRECTION);
+            }
+        }
+        else {
+            value = {};
+        }
+        this.objRefCache[entityId] = value;
+        return value;
+    }
+    getMappingClass(entity, mapping) {
+        const entityTypePath = entity['typePath'];
+        const typeMapKey = mapping['typeMapKey'];
+        let objClass = typeMapKey[entityTypePath];
+        const entityType = entity['entityType'];
+        if (!objClass) {
+            objClass = this.typeUtils.getEventObjectClass(entityType, entity);
+        }
+        if (!objClass) {
+            objClass = entityType;
+        }
+        return objClass;
+    }
+    async setEntityValues(entity, data, keysToSkip = []) {
+        const type = await this.typeUtils.getTypeById(entity.typeId);
+        keysToSkip = keysToSkip.concat(['updatedOn', 'updatedById', 'createdOn', 'createdById', 'modifiedAt', 'orgId', 'createdAt', 'id', 'typeId', 'typePath', 'workspaceId']);
+        let typeProps = this.typeUtils.filterTypeProperties(type, entity);
+        typeProps = typeProps.filter(prop => !keysToSkip.includes(prop['slug']));
+        const dataKeys = Object.getOwnPropertyNames(data);
+        typeProps = typeProps.filter(prop => dataKeys.includes(prop['slug']));
+        for (const prop of typeProps) {
+            const propertyType = prop['propertyType'];
+            const slug = prop['slug'];
+            let keyName = slug;
+            if (propertyType === 'userList' || propertyType === 'object_reference') {
+                keyName = slug + 'Id';
+            }
+            entity[keyName] = await this.getEntityValue(prop, data);
+        }
+        return entity;
+    }
+    async getEntityValues(objectClass, data, keysToSkip = []) {
+        const entityValues = {};
+        const tco = await this.typeUtils.getEntityTypeClientOptionsUsingMapping(this.transformMapFile, this.mapFileUtil, data);
+        const type = await this.typeUtils.getByRootAndPath(tco);
+        const typePath = type['typePath'];
+        if (typePath && (typePath.startsWith('item') || typePath.startsWith('project-item'))) {
+            if (['LCSProduct', 'LCSProductSeasonLink'].includes(objectClass)) {
+                entityValues['roles'] = ['family'];
+            }
+            else {
+                entityValues['roles'] = ['color', 'option'];
+            }
+        }
+        let typeProps = this.typeUtils.filterTypeProperties(type, entityValues);
+        typeProps = typeProps.filter(prop => !keysToSkip.includes(prop['slug']));
+        for (const prop of typeProps) {
+            const slug = prop['slug'];
+            const value = await this.getEntityValue(prop, data);
+            if (value) {
+                entityValues[slug] = value;
+            }
+        }
+        return entityValues;
+    }
+    async getEntityValue(prop, data) {
+        const propertyType = prop['propertyType'];
+        const slug = prop['slug'];
+        const nd = data[slug];
+        let value;
+        if (['string', 'text'].includes(propertyType)) {
+            value = nd;
+        }
+        else if (['number', 'currency', 'percent', 'sequence'].includes(propertyType)) {
+            value = (null === nd) ? 0 : nd;
+        }
+        else if ('date' === propertyType) {
+            if (nd) {
+                const d = new Date(nd);
+                value = d.toISOString();
+            }
+            else {
+                value = null;
+            }
+        }
+        else if ('boolean' === propertyType) {
+            value = (nd) ? true : false;
+        }
+        else if ('choice' === propertyType) {
+            value = this.setEnumerationKeys(prop, nd, this.useDisplayForEnumerationMatching);
+        }
+        else if ('multi_select' === propertyType) {
+            value = this.setEnumerationKeys(prop, nd, this.useDisplayForEnumerationMatching);
+        }
+        else if ('object_reference' === propertyType) {
+            value = await this.setObjectReferenceValue(prop, nd);
+        }
+        else if ('image' === propertyType) {
+        }
+        else if ('formula' === propertyType) {
+        }
+        else if ('json' === propertyType) {
+        }
+        else if ('userList' === propertyType) {
+            value = await this.setUserListValue(prop, nd);
+        }
+        return value;
+    }
+    setEnumerationKeys(prop, nd, matchByDisplay) {
+        const propertyType = prop['propertyType'];
+        let value;
+        if (['choice', 'multi_select'].includes(propertyType)) {
+            const options = prop['options'] || [];
+            if ('choice' === propertyType) {
+                if (nd) {
+                    const matchKey = (matchByDisplay) ? 'display' : 'value';
+                    const option = options.find(option => option[matchKey] == nd[matchKey]);
+                    if (option) {
+                        value = option.value;
+                    }
+                }
+                else {
+                    value = undefined;
+                }
+            }
+            else if ('multi_select' === propertyType) {
+                value = [];
+                const matchKey = (matchByDisplay) ? 'display' : 'value';
+                if (nd instanceof Array) {
+                    nd.forEach(selectedOpt => {
+                        const optionObject = options.find(option => option[matchKey] == selectedOpt[matchKey]);
+                        if (optionObject) {
+                            const option = optionObject.value;
+                            value.push(option);
+                        }
+                    });
+                }
+            }
+        }
+        return value;
+    }
+    getPersistableChanges(entity, changes) {
+        const entityCompareValues = {};
+        for (const key of (Object.getOwnPropertyNames(changes))) {
+            entityCompareValues[key] = entity[key];
+        }
+        const diffs = util_1.ObjectUtil.compareDeep(entityCompareValues, changes, '');
+        const diffValues = {};
+        if (diffs && diffs.length > 0) {
+            for (const diff of diffs) {
+                diffValues[diff.propertyName] = diff.newValue;
+            }
+        }
+        return diffValues;
+    }
+    async setObjectReferenceValue(prop, nd) {
+        let objectReferenceId = "";
+        if (!nd) {
+            return objectReferenceId;
+        }
+        if (this.transformMapFile) {
+            const mapKey = await type_conversion_utils_1.TypeConversionUtils.getMapKeyFromObject(this.transformMapFile, this.mapFileUtil, nd, type_conversion_utils_1.TypeConversionUtils.FLEX2VIBE_DIRECTION);
+            nd = await map_utils_1.MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, nd, mapKey, type_conversion_utils_1.TypeConversionUtils.FLEX2VIBE_DIRECTION);
+        }
+        const entityType = prop['referencedTypeRootSlug'];
+        const entityTypePath = prop['referencedTypePath'];
+        const entityKeys = Object.keys(nd);
+        const identifierKeys = await type_conversion_utils_1.TypeConversionUtils.getIdentifierPropertiesFromObject(this.transformMapFile, this.mapFileUtil, nd);
+        const hasAllIdentifiers = identifierKeys.every(key => entityKeys.includes(key));
+        if (identifierKeys.length == 0 || !hasAllIdentifiers) {
+            console.warn(`The inbound ${entityType} for prop '${prop['slug']}' doesnt have all "identifier" properties, so there is no processing. Identifier properties: ${identifierKeys}`);
+            return objectReferenceId;
+        }
+        const rootType = await this.typeUtils.getByRootAndPath({ root: entityType });
+        const rootTypeProps = this.typeUtils.filterTypeProperties(rootType, nd);
+        let rootTypeCriteria = {};
+        let typeCriteria = {};
+        identifierKeys.forEach(keyName => {
+            const foundInObjects = rootTypeProps.some(obj => obj.slug === keyName);
+            if (foundInObjects) {
+                rootTypeCriteria[keyName] = nd[keyName];
+            }
+            else {
+                typeCriteria[keyName] = nd[keyName];
+            }
+        });
+        const combinedCriteria = { ...rootTypeCriteria, ...typeCriteria, typePath: entityTypePath };
+        const cacheKey = Object.values(combinedCriteria).join('_');
+        if (this.objRefCache[cacheKey]) {
+            if (app_framework_1.Logger.isDebugOn()) {
+                console.debug(`object reference cache hit: ${cacheKey}`);
+            }
+            return this.objRefCache[cacheKey];
+        }
+        let arrObjectReferences = await this.getAllObjectReferences(entityType, rootTypeCriteria);
+        if (entityType !== entityTypePath) {
+            arrObjectReferences = this.checkKeysAndValues(typeCriteria, arrObjectReferences, entityTypePath);
+        }
+        if (arrObjectReferences.length) {
+            if (arrObjectReferences.length === 1) {
+                objectReferenceId = arrObjectReferences[0].id;
+            }
+            else {
+                console.warn(`The passed in object reference criteria has duplicate records found ${JSON.stringify(combinedCriteria)}.`);
+            }
+        }
+        if (!objectReferenceId) {
+            console.warn(`The passed in object reference criteria ${JSON.stringify(combinedCriteria)} didn't match any entities.`);
+            return objectReferenceId;
+        }
+        this.objRefCache[cacheKey] = objectReferenceId;
+        return objectReferenceId;
+    }
+    async getAllObjectReferences(entityType, rootTypeCriteria, postProcessCriteria = null) {
+        const entities = new sdk_1.Entities();
+        let loads = [];
+        let nextPageKey;
+        let usedV2 = false;
+        do {
+            const take = 1000;
+            const loadPage = await entities.get({
+                entityName: entityType,
+                criteria: rootTypeCriteria,
+                apiVersion: sdk_1.API_VERSION.V2,
+                take,
+                nextPageKey,
+            });
+            nextPageKey = loadPage?.nextPageKey;
+            if (Object.keys(loadPage).includes('results')) {
+                usedV2 = true;
+                let postProcessedResults = this.filterOutArchivedAndTrashedEntities(loadPage?.results);
+                if (postProcessedResults?.length > 0 && postProcessCriteria && Object.keys(postProcessCriteria).length !== 0) {
+                    const subEntityTypePath = rootTypeCriteria.typePath || entityType;
+                    postProcessedResults = this.checkKeysAndValues(postProcessCriteria, postProcessedResults, subEntityTypePath);
+                }
+                loads.push(...postProcessedResults);
+            }
+            else {
+                nextPageKey = null;
+            }
+        } while (nextPageKey);
+        if (!usedV2) {
+            const take = 1000;
+            let skip = 0;
+            let done = false;
+            while (!done) {
+                const loadPage = await entities.get({
+                    entityName: entityType,
+                    criteria: rootTypeCriteria,
+                    take,
+                    skip,
+                });
+                let postProcessedResults = this.filterOutArchivedAndTrashedEntities(loadPage);
+                if (postProcessCriteria && Object.keys(postProcessCriteria).length !== 0) {
+                    const subEntityTypePath = rootTypeCriteria.typePath || entityType;
+                    postProcessedResults = this.checkKeysAndValues(postProcessCriteria, postProcessedResults, subEntityTypePath);
+                }
+                loads.push(...postProcessedResults);
+                if (loadPage.length !== take) {
+                    done = true;
+                }
+                else {
+                    skip += take;
+                }
+            }
+        }
+        return loads;
+    }
+    checkKeysAndValues(criteria, arrayOfObjects, entityTypePath) {
+        let arrOfMatchObjects = [];
+        for (let i = 0; i < arrayOfObjects.length; i++) {
+            const currentObj = arrayOfObjects[i];
+            let found = true;
+            if (entityTypePath && currentObj['typePath']) {
+                const currentObjPath = '' + currentObj['typePath'];
+                if (!currentObjPath.startsWith(entityTypePath)) {
+                    found = false;
+                }
+            }
+            for (const key in criteria) {
+                if (!(key in currentObj) || currentObj[key] !== criteria[key]) {
+                    found = false;
+                    break;
+                }
+            }
+            if (found) {
+                arrOfMatchObjects.push(currentObj);
+            }
+        }
+        return arrOfMatchObjects;
+    }
+    filterOutArchivedAndTrashedEntities(entities) {
+        if (!entities || !Array.isArray(entities) || entities.length === 0) {
+            return [];
+        }
+        return entities.filter(entity => {
+            const isArchived = entity?.isArchived;
+            const isTrashed = entity?.isTrashed;
+            return !isArchived && !isTrashed;
+        });
+    }
+    async setUserListValue(prop, nd) {
+        if (!nd?.email) {
+            return "";
+        }
+        let cacheUser = DataConverter.getFromStaticCache(nd.email);
+        if (cacheUser) {
+            if (app_framework_1.Logger.isDebugOn()) {
+                console.debug('user cache hit: ' + nd.email);
+            }
+            await this.processGroupMemberCheck(prop, nd.email);
+            return cacheUser;
+        }
+        const user = await this.getUserByEmail(nd);
+        const userId = (user) ? user.id : undefined;
+        if (userId) {
+            DataConverter.setToStaticCache(nd.email, userId);
+            await this.processGroupMemberCheck(prop, nd.email);
+        }
+        return userId;
+    }
+    async getUserByEmail(nd) {
+        let userOrg = undefined;
+        let count = 0;
+        let size = 0;
+        let emailInput = nd?.email.toLowerCase();
+        const entities = new sdk_1.Entities();
+        const getOptionsCriteria = {
+            entityName: 'user-org',
+            take: 1000
+        };
+        do {
+            const userBatch = await entities.get(getOptionsCriteria);
+            userOrg = userBatch.find(uo => uo?.userEmail.toLowerCase() === emailInput);
+        } while (!userOrg && size == getOptionsCriteria.take && count < 15);
+        return userOrg?.user;
+    }
+    async processGroupMemberCheck(prop, userEmail) {
+        let arrUserList = [];
+        if (this.userRefCache[prop.typePropertyUserListId]) {
+            arrUserList = this.userRefCache[prop.typePropertyUserListId];
+        }
+        else {
+            const userListResult = await new sdk_1.Entities().get({
+                entityName: 'user-list',
+                id: prop.typePropertyUserListId
+            });
+            if (userListResult && Object.keys(userListResult).length) {
+                arrUserList = userListResult.userList;
+                this.userRefCache[prop.typePropertyUserListId] = arrUserList;
+            }
+        }
+        if (arrUserList.length) {
+            const result = arrUserList.find(element => element['display'] === userEmail);
+            if (!result) {
+                console.warn(`The passed in user ${userEmail} in property slug ${prop.slug} should be a member of the group associated with the property 'typePropertyUserListId'`);
+            }
+        }
+    }
+    async getUserListValue(prop, newData) {
+        const slug = prop['slug'];
+        if (app_framework_1.Logger.isDebugOn()) {
+            console.debug('getUserListValue-prop: ' + slug);
+        }
+        const entityId = newData[slug + 'Id'];
+        if (!entityId) {
+            return {};
+        }
+        const cacheUser = DataConverter.getFromStaticCache(entityId);
+        if (cacheUser) {
+            if (app_framework_1.Logger.isDebugOn()) {
+                console.debug('user cache hit: ' + entityId);
+            }
+            return Object.assign({}, cacheUser);
+        }
+        const user = await this.getUserById(entityId);
+        const value = (user) ? {
+            email: user.email,
+            firstName: user.first,
+            lastName: user.last,
+            isSsoUser: user.isSsoUser,
+        } : undefined;
+        if (value) {
+            DataConverter.setToStaticCache(entityId, value);
+        }
+        return value;
+    }
+    async getUserById(userId) {
+        let userOrg = undefined;
+        let count = 0;
+        let size = 0;
+        const entities = new sdk_1.Entities();
+        const getOptionsCriteria = {
+            entityName: 'user-org',
+            take: 1000
+        };
+        do {
+            const userBatch = await entities.get(getOptionsCriteria);
+            userOrg = userBatch.find(uo => uo?.user?.id === userId);
+        } while (!userOrg && size == getOptionsCriteria.take && count < 15);
+        return userOrg?.user;
+    }
+}
+exports.DataConverter = DataConverter;
+DataConverter.staticUserCache = {};

package/lib/util/data-converter.spec.d.ts

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