@contrail/flexplm 1.0.11 → 1.0.13

package/lib/util/data-converter.js

@@ -0,0 +1,318 @@
+"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 transform_data_1 = require("@contrail/transform-data");
+const app_framework_1 = require("@contrail/app-framework");
+const util_1 = require("@contrail/util");
+class DataConverter {
+    constructor(config, mapFileUtil) {
+        this.config = config;
+        this.mapFileUtil = mapFileUtil;
+        this.useDisplayForEnumerationMatching = false;
+        this.objRefCache = {};
+        this.typeUtils = new type_utils_1.TypeUtils();
+        this.transformMapFile = this.config['transformMapFile'];
+        this.useDisplayForEnumerationMatching = this.config['dataConverter']
+            && this.config['dataConverter']['useDisplayForEnumerationMatching'];
+    }
+    async getFlexPLMObjectDataFromEvent(event, dataToSkip) {
+        return this.getFlexPLMObjectData(event.newData, dataToSkip, true);
+    }
+    async getFlexPLMObjectData(newData, dataToSkip, expandObjRef) {
+        if (app_framework_1.Logger.isDebugOn()) {
+            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, expandObjRef);
+        }
+        if (app_framework_1.Logger.isDebugOn()) {
+            console.debug('getFlexPLMObjectData-data:  ' + JSON.stringify(data));
+        }
+        return data;
+    }
+    async getFlexPLMValue(prop, newData, expandObjRef) {
+        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, expandObjRef);
+            if (app_framework_1.Logger.isDebugOn()) {
+                console.debug('object_reference: ' + JSON.stringify(value));
+            }
+        }
+        else if ('image' === propertyType) {
+        }
+        else if ('formula' === propertyType) {
+            value = nd;
+        }
+        else if ('json' === propertyType) {
+            value = nd;
+        }
+        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);
+                    }
+                }
+                else {
+                    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, expandObjRef = false) {
+        const slug = prop['slug'];
+        console.debug('getObjectReferenceValue-prop: ' + slug);
+        let value = newData[slug];
+        const entityType = prop['referencedTypeRootSlug'];
+        const entityId = newData[slug + 'Id'];
+        if (!value && expandObjRef) {
+            if (entityId) {
+                if (this.objRefCache[entityId]) {
+                    console.log('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) {
+            const unprocessedValue = value;
+            const objectClass = this.typeUtils.getEventObjectClass(entityType, newData);
+            value = await this.getFlexPLMObjectData(value, [], false);
+            value['entityReference'] = entityType + ':' + entityId;
+            value['objectClass'] = objectClass;
+            value['typePath'] = unprocessedValue['typePath'];
+            if (this.transformMapFile) {
+                const wholeMap = await this.mapFileUtil.getMapFile(this.transformMapFile);
+                const objClass = this.getMappingClass(unprocessedValue, wholeMap);
+                const mapping = await this.mapFileUtil.getMappingSection(this.transformMapFile, objClass, 'vibe2flex');
+                if (mapping) {
+                    const tasks = transform_data_1.MapFileUtil.getTransformTasks(mapping);
+                    if (tasks.length > 0) {
+                        const convertedArray = transform_data_1.TransformProcessor.transformData([value], tasks);
+                        value = convertedArray[0];
+                    }
+                }
+            }
+        }
+        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', '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 slug = prop['slug'];
+            entity[slug] = await this.getEntityValue(prop, data);
+        }
+        return entity;
+    }
+    async getEntityValues(objectClass, data, keysToSkip = []) {
+        const entityValues = {};
+        const tco = this.typeUtils.getEntityTypeClientOptions(objectClass, 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) {
+        }
+        else if ('image' === propertyType) {
+            console.log('TODO');
+        }
+        else if ('formula' === propertyType) {
+            console.log('TODO');
+        }
+        else if ('json' === propertyType) {
+            console.log('TODO');
+        }
+        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;
+    }
+}
+exports.DataConverter = DataConverter;

package/lib/util/federation.d.ts

@@ -0,0 +1,15 @@
+import { FederationRecord } from './interfaces';
+export declare class Federation {
+    private CHUNK_SIZE;
+    getFederatedMappedRefId(entityType: string, entityId: string): Promise<string>;
+    createFederatedRecord(eventBody: any): Promise<any>;
+    getFederationRecordFromMappedRefId(mappedRefId: string): Promise<FederationRecord>;
+    static getEntityId(fedRecord: FederationRecord): {
+        entityType: string;
+        entityId: string;
+    };
+    getEntityFromMappedRefId(mappedRefId: string): Promise<any>;
+    getFederationRecordsFromIds(ids: string[]): Promise<FederationRecord[]>;
+    getFederationRecordsFromIdsBulk(ids: string[]): Promise<FederationRecord[]>;
+    splitIntoChunksByLen(arr: any, len: any): any[];
+}

package/lib/util/federation.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Federation = void 0;
+const sdk_1 = require("@contrail/sdk");
+const p_limit_1 = __importDefault(require("p-limit"));
+const limit = (0, p_limit_1.default)(30);
+const FED_CONFIG = {
+    appIdentifier: '@vibeiq/flexplm-connector',
+    federationSchema: 'DEFAULT'
+};
+class Federation {
+    constructor() {
+        this.CHUNK_SIZE = 50;
+    }
+    async getFederatedMappedRefId(entityType, entityId) {
+        const criteria = {
+            reference: entityType + ':' + entityId,
+            appIdentifier: FED_CONFIG.appIdentifier,
+            federationSchema: FED_CONFIG.federationSchema
+        };
+        console.log('getFederatedMappedRefId: ' + JSON.stringify(criteria));
+        const fedRecords = await new sdk_1.Entities().get({
+            entityName: 'federation',
+            criteria
+        });
+        const federatedId = (fedRecords[0])
+            ? fedRecords[0]['mappedReference']
+            : '';
+        return federatedId;
+    }
+    async createFederatedRecord(eventBody) {
+        const itemResults = eventBody.payload;
+        for (let i = 0; i < itemResults.length; i++) {
+            if (!itemResults[i].federatedId) {
+                continue;
+            }
+            const payload = {
+                appIdentifier: FED_CONFIG.appIdentifier,
+                reference: itemResults[i].entityReference,
+                mappedReference: itemResults[i].federatedId,
+                federationSchema: FED_CONFIG.federationSchema
+            };
+            try {
+                const results = await new sdk_1.Entities().create({ entityName: 'federation', object: payload });
+                return results;
+            }
+            catch (error) {
+                console.log('createFederatedRecord-error: ', error);
+                throw new Error('Error creating federation record: ' + error.message);
+            }
+        }
+    }
+    async getFederationRecordFromMappedRefId(mappedRefId) {
+        const criteria = {
+            appIdentifier: FED_CONFIG.appIdentifier,
+            mappedReference: mappedRefId,
+            federationSchema: FED_CONFIG.federationSchema
+        };
+        try {
+            const fedRecords = await new sdk_1.Entities().get({
+                entityName: 'federation',
+                criteria
+            });
+            return (fedRecords && fedRecords[0]) ? fedRecords[0] : undefined;
+        }
+        catch (e) {
+            console.log('getFederationData-error: ' + e.message);
+        }
+        return undefined;
+    }
+    static getEntityId(fedRecord) {
+        const entityString = fedRecord['reference'];
+        const entitySplit = entityString.split(':');
+        const entityType = entitySplit[0];
+        const entityId = entitySplit[1];
+        return { entityType, entityId };
+    }
+    async getEntityFromMappedRefId(mappedRefId) {
+        const fedRecord = await this.getFederationRecordFromMappedRefId(mappedRefId);
+        console.log('fedRecord: ' + JSON.stringify(fedRecord));
+        if (!fedRecord) {
+            console.log('Federation Record doesnt exist. Cant get entity!');
+            return;
+        }
+        const { entityType, entityId } = Federation.getEntityId(fedRecord);
+        const criteria = {
+            id: entityId
+        };
+        const entities = await new sdk_1.Entities().get({
+            entityName: entityType,
+            criteria
+        });
+        const entity = (entities && entities[0]) ? entities[0] : undefined;
+        return entity;
+    }
+    async getFederationRecordsFromIds(ids) {
+        const fedRecords = [];
+        for (let i = 0; i < ids.length; i++) {
+            const criteria = {
+                reference: ids[i],
+                appIdentifier: FED_CONFIG.appIdentifier,
+                federationSchema: FED_CONFIG.federationSchema
+            };
+            const recs = await new sdk_1.Entities().get({
+                entityName: 'federation',
+                criteria
+            });
+            if (recs[0]) {
+                fedRecords.push(recs[0]);
+            }
+        }
+        return fedRecords;
+    }
+    async getFederationRecordsFromIdsBulk(ids) {
+        const chunks = this.splitIntoChunksByLen(ids, this.CHUNK_SIZE);
+        const fedRecords = [];
+        const federatedPromises = [];
+        const entities = new sdk_1.Entities();
+        for (const chunk of chunks) {
+            const fedPromise = limit(async () => {
+                const criteria = {
+                    references: chunk,
+                    appIdentifier: FED_CONFIG.appIdentifier,
+                    federationSchema: FED_CONFIG.federationSchema
+                };
+                const records = await entities.get({
+                    entityName: 'federation',
+                    criteria
+                });
+                fedRecords.push(...records);
+            });
+            federatedPromises.push(fedPromise);
+        }
+        await Promise.all(federatedPromises);
+        return fedRecords;
+    }
+    splitIntoChunksByLen(arr, len) {
+        const chunks = [], n = arr?.length;
+        let i = 0;
+        while (i < n) {
+            chunks.push(arr.slice(i, i += len));
+        }
+        return chunks;
+    }
+}
+exports.Federation = Federation;

package/lib/util/flexplm-connect.d.ts

@@ -0,0 +1,16 @@
+import { FCConfig, FlexPLMResponseData, PayloadType } from './interfaces';
+export declare class FlexPLMConnect {
+    private config;
+    private vibeEventEndpoint;
+    payloadSendAsArray: boolean;
+    constructor(_config: FCConfig, endPoint?: any, payloadAsArray?: any);
+    private getRequestOptions;
+    getCSRF(): Promise<{
+        nonce_key: any;
+        nonce: any;
+    }>;
+    sendRequest(csrf: any, payload: any): Promise<Response>;
+    protected processRequest(payload: any): Promise<FlexPLMResponseData>;
+    sendToFlexPLM(payload: PayloadType): Promise<FlexPLMResponseData>;
+    sendMultipleToFlexPLM(payload: PayloadType[]): Promise<FlexPLMResponseData>;
+}

package/lib/util/flexplm-connect.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlexPLMConnect = void 0;
+const app_framework_1 = require("@contrail/app-framework");
+class FlexPLMConnect {
+    constructor(_config, endPoint = undefined, payloadAsArray = undefined) {
+        this.vibeEventEndpoint = '';
+        this.payloadSendAsArray = true;
+        this.config = _config;
+        this.vibeEventEndpoint = (endPoint)
+            ? endPoint
+            : this.config.vibeEventEndpoint;
+        this.payloadSendAsArray = (payloadAsArray != undefined)
+            ? payloadAsArray
+            : this.config['payloadDefaultAsArray'];
+    }
+    getRequestOptions(method) {
+        const csrfOptions = {
+            method,
+            headers: {
+                'Content-Type': 'application/json',
+                PLM_ENV: this.config.plmEnviornment,
+                Authorization: 'Basic ' + Buffer.from(`${this.config.userName()}:${this.config.password()}`, 'binary').toString('base64')
+            }
+        };
+        if (app_framework_1.Logger.isInfoOn()) {
+            const logOptions = JSON.parse(JSON.stringify(csrfOptions));
+            logOptions['headers']['Authorization'] = logOptions?.headers?.Authorization.substring(0, 9);
+            console.info('csrfOptions: ' + JSON.stringify(logOptions));
+        }
+        return csrfOptions;
+    }
+    async getCSRF() {
+        const urlContext = this.config.urlContext;
+        const csrfEndpoint = this.config.csrfEndpoint;
+        const csrfURL = this.config.apiHost + urlContext + csrfEndpoint;
+        console.info('csrfURL: ' + csrfURL);
+        const csrfOptions = this.getRequestOptions('GET');
+        const response = await fetch(csrfURL, csrfOptions);
+        if (response.status >= 300) {
+            const message = 'Error connecting to FlexPLM:status: ' + response.status;
+            console.error(message);
+            console.error(await response.text());
+            throw new Error(message);
+        }
+        try {
+            const body = await response.json();
+            const nonce_key = body.items[0].attributes.nonce_key;
+            const nonce = body.items[0].attributes.nonce;
+            console.info('nonce_key: ' + nonce_key);
+            console.info('nonce: ' + nonce);
+            return {
+                nonce_key,
+                nonce
+            };
+        }
+        catch (e) {
+            const message = 'Error connecting to FlexPLM: ' + e.message;
+            console.error(message);
+            console.error(await response.text());
+            throw new Error(message);
+        }
+    }
+    async sendRequest(csrf, payload) {
+        if (this.payloadSendAsArray && !Array.isArray(payload)) {
+            payload = [payload];
+        }
+        const xferOptions = this.getRequestOptions('POST');
+        xferOptions['body'] = JSON.stringify(payload);
+        xferOptions.headers[csrf.nonce_key] = csrf.nonce;
+        const urlContext = this.config.urlContext;
+        const vibeEventsURL = this.config.apiHost + urlContext + '/servlet/rest' + this.vibeEventEndpoint;
+        if (app_framework_1.Logger.isInfoOn()) {
+            console.info('Request:');
+            console.info('vibeEventsURL: ' + vibeEventsURL);
+            const logOptions = JSON.parse(JSON.stringify(xferOptions));
+            logOptions['headers']['Authorization'] = logOptions?.headers?.Authorization.substring(0, 9);
+            console.info('csrfOptions: ' + JSON.stringify(logOptions));
+            console.info('Making call to xfer data to FlexPLM');
+        }
+        const eventResponse = await fetch(vibeEventsURL, xferOptions);
+        return eventResponse;
+    }
+    async processRequest(payload) {
+        if (!payload) {
+            const message = 'No payload to send to FlexPLM';
+            console.error(message);
+            throw new Error(message);
+        }
+        if (app_framework_1.Logger.isInfoOn()) {
+            console.info('payload: ' + JSON.stringify(payload));
+        }
+        const csrf = await this.getCSRF();
+        if (!csrf) {
+            const message = 'Failed to get CSRF nonce';
+            console.error(message);
+            throw new Error(message);
+        }
+        const response = await this.sendRequest(csrf, payload);
+        const status = response.status;
+        if (status >= 300) {
+            const message = 'Error sending data to FlexPLM:status: ' + response.status;
+            console.error(message);
+            console.error(await response.text());
+            throw new Error(message);
+        }
+        try {
+            const data = await response.json();
+            const res = {
+                status,
+                data
+            };
+            console.log('eventResponse.status: ' + status);
+            return res;
+        }
+        catch (e) {
+            const message = 'Error getting json data from FlexPLM: ' + e.message;
+            console.error(message);
+            console.error(await response.text());
+            throw new Error(message);
+        }
+    }
+    async sendToFlexPLM(payload) {
+        return await this.processRequest(payload);
+    }
+    async sendMultipleToFlexPLM(payload) {
+        return await this.processRequest(payload);
+    }
+}
+exports.FlexPLMConnect = FlexPLMConnect;