@contrail/flexplm 1.0.12 → 1.0.13

package/lib/index.d.ts

@@ -8,3 +8,5 @@ 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

@@ -24,3 +24,5 @@ __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/map-utils.d.ts

@@ -0,0 +1,3 @@
+export declare class MapUtil {
+    static applyTransformMap(transformMapFile: any, mapFileUtil: any, data: any, type: string, direction: string): Promise<any>;
+}

package/lib/util/map-utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapUtil = void 0;
+const transform_data_1 = require("@contrail/transform-data");
+class MapUtil {
+    static async applyTransformMap(transformMapFile, mapFileUtil, data, type, direction) {
+        if (transformMapFile) {
+            const mapping = await mapFileUtil.getMappingSection(transformMapFile, type, direction);
+            if (mapping) {
+                const tasks = transform_data_1.MapFileUtil.getTransformTasks(mapping);
+                if (tasks.length > 0) {
+                    const convertedArray = transform_data_1.TransformProcessor.transformData([data], tasks);
+                    data = convertedArray[0];
+                }
+            }
+        }
+        return data;
+    }
+}
+exports.MapUtil = MapUtil;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/flexplm",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "Library used for integration with flexplm.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",