@contrail/flexplm 1.0.11 → 1.0.13

package/lib/flexplm-request.d.ts

@@ -0,0 +1,3 @@
+export declare class FlexPLMRequest {
+    static request(path: string, data: any): Promise<any>;
+}

package/lib/flexplm-request.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlexPLMRequest = void 0;
+const axios_1 = __importDefault(require("axios"));
+const BASE_URL = 'https://PP-2006031951wo.portal.ptc.io/Windchill/servlet/rest/cdee';
+const BASE_CONFIG = {
+    method: 'POST',
+    headers: {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+        'CSRF_NONCE': '2OaLp+0dWNBtrkTwtdDC491zaacu6Hykvqi/lpl6bZgJ/QXBrK/B1J5FErMkmAmktr/I3thcbO1Xn3HJ7Ne/l9kpaedUmn7H75Xey4ZbNLsenW+anM3vxIZ7ELosk3k=',
+        'Authorization': 'Basic d2NhZG1pbjpSZXRhaWwyMDIwLQ==',
+        'Cookie': 'JSESSIONID=36D5B3C74C1F963C6C73E9AF5B6BDA78.tomcat1; JSESSIONID=B8090C802D8548EA773C97F5886FAB79.tomcat1',
+    },
+};
+class FlexPLMRequest {
+    static async request(path, data) {
+        const config = Object.assign({}, BASE_CONFIG);
+        config.url = BASE_URL + path;
+        config.data = data;
+        try {
+            const resp = await (0, axios_1.default)(config);
+            return Promise.resolve(resp.data);
+        }
+        catch (error) {
+            console.error(`${FlexPLMRequest} error: ${error.message}`);
+            return Promise.resolve(null);
+        }
+    }
+}
+exports.FlexPLMRequest = FlexPLMRequest;

package/lib/flexplm-utils.d.ts

@@ -0,0 +1,5 @@
+export declare class FlexPLMUtils {
+    static convertTypePath: (path: string) => string;
+    static getParentTypePath: (path: string) => string;
+    static computeLevelFromPath(path: string): number;
+}

package/lib/flexplm-utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlexPLMUtils = void 0;
+class FlexPLMUtils {
+    static computeLevelFromPath(path) {
+        return (path.match(/:/g) || []).length + 1;
+    }
+}
+exports.FlexPLMUtils = FlexPLMUtils;
+FlexPLMUtils.convertTypePath = (path) => {
+    if (!path) {
+        return null;
+    }
+    let newPath = path;
+    while (newPath.indexOf('\\') > 1) {
+        newPath = newPath.replace('\\', ':');
+    }
+    while (newPath.indexOf('[') > 1) {
+        newPath = newPath.replace('[', '*');
+    }
+    while (newPath.indexOf(']') > 1) {
+        newPath = newPath.replace(']', '*');
+    }
+    while (newPath.indexOf(' ') > 1) {
+        newPath = newPath.replace(' ', '_');
+    }
+    newPath = newPath.toLowerCase();
+    return newPath;
+};
+FlexPLMUtils.getParentTypePath = (path) => {
+    const newPath = FlexPLMUtils.convertTypePath(path);
+    return (!newPath || newPath.indexOf(':') < 0) ? null : newPath.substring(0, newPath.lastIndexOf(':'));
+};

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+export * from './flexplm-request';
+export * from './flexplm-utils';
+export * from './util/config-defaults';
+export * from './util/data-converter';
+export * from './util/federation';
+export * from './util/flexplm-connect';
+export * from './util/interfaces';
+export * from './util/logger-config';
+export * from './util/thumbnail-util';
+export * from './util/type-utils';
+export * from './util/map-utils';
+export * from './process-entity/process-entity';

package/lib/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./flexplm-request"), exports);
+__exportStar(require("./flexplm-utils"), exports);
+__exportStar(require("./util/config-defaults"), exports);
+__exportStar(require("./util/data-converter"), exports);
+__exportStar(require("./util/federation"), exports);
+__exportStar(require("./util/flexplm-connect"), exports);
+__exportStar(require("./util/interfaces"), exports);
+__exportStar(require("./util/logger-config"), exports);
+__exportStar(require("./util/thumbnail-util"), exports);
+__exportStar(require("./util/type-utils"), exports);
+__exportStar(require("./util/map-utils"), exports);
+__exportStar(require("./process-entity/process-entity"), exports);

package/lib/process-entity/process-entity.d.ts

@@ -0,0 +1,26 @@
+import { FCConfig, EntityPayloadType } from '../util/interfaces';
+import { DataConverter } from '../util/data-converter';
+import { TypeUtils } from '../util/type-utils';
+import { MapFileUtil } from '@contrail/transform-data';
+export declare abstract class ProcessBaseEntity {
+    protected config: FCConfig;
+    protected dc: DataConverter;
+    protected mapFileUtil: MapFileUtil;
+    protected baseType: string;
+    protected typeUtil: TypeUtils;
+    protected transformMapFile: string;
+    protected entities: any;
+    constructor(config: FCConfig, dc: DataConverter, mapFileUtil: MapFileUtil, baseType: string);
+    inbound(event: EntityPayloadType): Promise<any>;
+    handleIncomingUpdate(event: EntityPayloadType): Promise<any>;
+    handleIncomingDelete(event: any): Promise<void>;
+    getTransformedData(event: any): Promise<any>;
+    getUpdatesForEntity(entity: any, inboundData: any): Promise<object>;
+    getVibeOwningKeys(entity: any): Promise<any[]>;
+    updateEntity(entityName: any, entity: any, diffs: any): Promise<any>;
+    protected abstract getIncomingEntity(event: any, inboundData: any): any;
+    outbound(event: any): Promise<void | import("../util/interfaces").FlexPLMResponseData>;
+    handleOutgoingUpsert(entityType: any, event: any): Promise<import("../util/interfaces").FlexPLMResponseData>;
+    handleOutgoingDelete(entityType: any, event: any): Promise<void>;
+    protected abstract getOutgoingUpsertPayload(entityType: any, event: any): Promise<EntityPayloadType>;
+}

package/lib/process-entity/process-entity.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessBaseEntity = void 0;
+const type_utils_1 = require("../util/type-utils");
+const flexplm_connect_1 = require("../util/flexplm-connect");
+const map_utils_1 = require("../util/map-utils");
+const sdk_1 = require("@contrail/sdk");
+const UNSUPPORTED_TYPE = 'Unsupported eventType.';
+class ProcessBaseEntity {
+    constructor(config, dc, mapFileUtil, baseType) {
+        this.config = config;
+        this.dc = dc;
+        this.mapFileUtil = mapFileUtil;
+        this.baseType = baseType;
+        this.typeUtil = new type_utils_1.TypeUtils();
+        this.transformMapFile = this.config['transformMapFile'];
+        this.entities = new sdk_1.Entities();
+    }
+    async inbound(event) {
+        const eventType = event.eventType;
+        console.log(`inbound entity: ${eventType}:${event.objectClass}`);
+        switch (eventType) {
+            case 'PERSIST':
+                return await this.handleIncomingUpdate(event);
+            case 'DELETE':
+                return await this.handleIncomingDelete(event);
+            default:
+                console.log(UNSUPPORTED_TYPE);
+                return {
+                    status: 500,
+                    data: { UNSUPPORTED_TYPE }
+                };
+        }
+    }
+    async handleIncomingUpdate(event) {
+        const inboundData = await this.getTransformedData(event);
+        const entity = await this.getIncomingEntity(event, inboundData);
+        if (!entity) {
+            const message = 'No entity found';
+            console.debug(message);
+            return {
+                status: 404,
+                data: { message }
+            };
+        }
+        else if (Object.keys(entity).length === 2 && entity?.status && entity?.data) {
+            return entity;
+        }
+        const diffs = await this.getUpdatesForEntity(entity, inboundData);
+        if (Object.getOwnPropertyNames(diffs).length == 0) {
+            const message = 'No Changes to persist for entity: ' + entity['id'];
+            console.log(message);
+            return {
+                status: 200,
+                data: { message }
+            };
+        }
+        return this.updateEntity(this.baseType, entity, diffs);
+    }
+    async handleIncomingDelete(event) {
+        console.warn('delete is not configured', event);
+    }
+    async getTransformedData(event) {
+        let inboundData = event.data;
+        console.debug('inboundData: ' + JSON.stringify(inboundData));
+        const objectClass = event.objectClass;
+        inboundData = await map_utils_1.MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, inboundData, objectClass, 'flex2vibe');
+        console.debug('Transformed-inboundData: ' + JSON.stringify(inboundData));
+        return inboundData;
+    }
+    async getUpdatesForEntity(entity, inboundData) {
+        const vibeOwningKeys = await this.getVibeOwningKeys(entity);
+        let updates = {
+            typeId: entity.typeId,
+            roles: entity.roles,
+            id: entity.id,
+        };
+        updates = await this.dc.setEntityValues(entity, inboundData, vibeOwningKeys);
+        for (const prop of ['typeId', 'roles', 'id']) {
+            delete updates[prop];
+        }
+        return this.dc.getPersistableChanges(entity, updates);
+    }
+    async getVibeOwningKeys(entity) {
+        let vibeOwningKeys = [];
+        if (this.transformMapFile) {
+            const wholeMap = await this.mapFileUtil.getMapFile(this.transformMapFile);
+            const objClass = this.dc.getMappingClass(entity, wholeMap);
+            if (objClass && wholeMap && wholeMap[objClass] && wholeMap[objClass]['vibeOwningKeys']) {
+                vibeOwningKeys = wholeMap[objClass]['vibeOwningKeys'];
+            }
+        }
+        console.debug('vibeOwningKeys: ' + vibeOwningKeys);
+        return vibeOwningKeys;
+    }
+    async updateEntity(entityName, entity, diffs) {
+        const options = {
+            entityName: entityName,
+            id: entity['id'],
+            object: diffs
+        };
+        console.log('options: ' + JSON.stringify(options));
+        return await new sdk_1.Entities().update(options);
+    }
+    async outbound(event) {
+        const entityType = event.entityType;
+        const eventType = event.eventType;
+        const entityId = event.id;
+        console.log(`outbound: ${entityType}:${entityId}`);
+        switch (eventType) {
+            case 'update':
+            case 'create':
+                return await this.handleOutgoingUpsert(entityType, event);
+            case 'delete':
+                return await this.handleOutgoingDelete(entityType, event);
+            default:
+                console.log(UNSUPPORTED_TYPE);
+                return {
+                    status: 500,
+                    data: { UNSUPPORTED_TYPE }
+                };
+        }
+    }
+    async handleOutgoingUpsert(entityType, event) {
+        const objectClass = this.typeUtil.getEventObjectClass(entityType, event.newData);
+        if (!objectClass) {
+            const message = 'ObjectClass must have a value.';
+            console.log(message);
+            return {
+                status: 500,
+                data: { message }
+            };
+        }
+        const payload = await this.getOutgoingUpsertPayload(entityType, event);
+        return await new flexplm_connect_1.FlexPLMConnect(this.config).sendToFlexPLM(payload);
+    }
+    async handleOutgoingDelete(entityType, event) {
+        console.warn('delete is not configured', entityType, event.oldData);
+    }
+}
+exports.ProcessBaseEntity = ProcessBaseEntity;

package/lib/util/config-defaults.d.ts

@@ -0,0 +1,6 @@
+import { FCConfig } from './interfaces';
+export declare class ConfigDefaults {
+    static NEED_CONFIG_VALUES: string;
+    static setConfigDefaults(config: any): Promise<FCConfig>;
+    static getConfigFile(fileId: string): Promise<any>;
+}

package/lib/util/config-defaults.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigDefaults = void 0;
+const sdk_1 = require("@contrail/sdk");
+const util_1 = require("@contrail/util");
+class ConfigDefaults {
+    static async setConfigDefaults(config) {
+        if (!config.apiHost || !config.userName || !config.password) {
+            throw new Error(ConfigDefaults.NEED_CONFIG_VALUES);
+        }
+        if (config?.itemPreDevelopmentLifecycleStages && !(config?.itemPreDevelopmentLifecycleStages instanceof Array)) {
+            config.itemPreDevelopmentLifecycleStages = config.itemPreDevelopmentLifecycleStages.split(',');
+        }
+        const defaultConfig = {
+            urlContext: '/Windchill',
+            sendMode: {
+                ASYNC_PUBLISH_SEASON: 'vibeiqfile'
+            },
+            itemPreDevelopmentLifecycleStages: ['concept'],
+            identifierAtts: {
+                LCSProduct: ['itemNumber'],
+                LCSSeason: ['flexPLMSeasonName'],
+                LCSSKU: ['itemNumber']
+            },
+            csrfEndpoint: '/servlet/rest/security/csrf',
+            vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+            payloadDefaultAsArray: true
+        };
+        const configArr = [defaultConfig];
+        if (config.configFile) {
+            const fileConfig = await ConfigDefaults.getConfigFile(config.configFile);
+            configArr.push(fileConfig);
+        }
+        configArr.push(config);
+        const outputConfig = util_1.ObjectUtil.mergeDeep({}, ...configArr);
+        const uName = outputConfig.userName;
+        const pass = outputConfig.password;
+        outputConfig.userName = () => uName;
+        outputConfig.password = () => pass;
+        outputConfig['OOBvibeEventEndpoint'] = '/rfa/vibeiq/vibeEvents';
+        console.log('outputConfig: ' + JSON.stringify(outputConfig));
+        return outputConfig;
+    }
+    static async getConfigFile(fileId) {
+        try {
+            const options = {
+                entityName: 'file',
+                id: fileId,
+            };
+            const file = await new sdk_1.Entities().get(options);
+            if (!file) {
+                console.log('failed to find file with id: ' + fileId);
+                return {};
+            }
+            const downloadUrl = file['downloadUrl'];
+            if (!downloadUrl) {
+                console.log('file didnt have downloadUrl. fileId: ' + fileId);
+                return {};
+            }
+            const response = await fetch(downloadUrl);
+            const config = await response.json();
+            return config ? config : {};
+        }
+        catch (e) {
+            console.log('Error getting config file: ' + fileId + '- ' + e.message);
+            return {};
+        }
+    }
+}
+exports.ConfigDefaults = ConfigDefaults;
+ConfigDefaults.NEED_CONFIG_VALUES = 'To connect to FlexPLM all these APP values need to be set apiHost, userName, and password';

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

@@ -0,0 +1,22 @@
+import { FCConfig } from './interfaces';
+import { MapFileUtil } from '@contrail/transform-data';
+export declare class DataConverter {
+    private config;
+    private mapFileUtil;
+    private typeUtils;
+    private transformMapFile;
+    private useDisplayForEnumerationMatching;
+    private objRefCache;
+    constructor(config: FCConfig, mapFileUtil: MapFileUtil);
+    getFlexPLMObjectDataFromEvent(event: any, dataToSkip: string[]): Promise<{}>;
+    getFlexPLMObjectData(newData: any, dataToSkip: string[], expandObjRef: boolean): Promise<{}>;
+    getFlexPLMValue(prop: any, newData: any, expandObjRef: boolean): Promise<any>;
+    getEnumerationValue(prop: any, nd: any): any;
+    getObjectReferenceValue(prop: any, newData: any, expandObjRef?: boolean): Promise<any>;
+    getMappingClass(entity: object, mapping: any): string;
+    setEntityValues(entity: any, data: any, keysToSkip?: string[]): Promise<any>;
+    getEntityValues(objectClass: string, data: any, keysToSkip?: string[]): Promise<{}>;
+    getEntityValue(prop: any, data: any): Promise<any>;
+    setEnumerationKeys(prop: any, nd: any, matchByDisplay: any): any;
+    getPersistableChanges(entity: object, changes: object): object;
+}