@contrail/flexplm 1.1.35 → 1.1.37

package/lib/entity-processor/base-entity-processor.d.ts

@@ -31,4 +31,7 @@ export declare abstract class BaseEntityProcessor {
     getOutboundEntityUpdates(event: any, flexResponse: any): Promise<any>;
     handleOutgoingDelete(entityType: any, event: any): Promise<void>;
     protected abstract getOutgoingUpsertPayload(entityType: any, event: any): Promise<EntityPayloadType>;
+    protected triggerSendEvent(triggerKey: string, event: any): Promise<any>;
+    protected sendUpsertToFlexPLM(event: any): Promise<any>;
+    protected getEntityUpsertPayload(event: any): Promise<EntityPayloadType>;
 }

package/lib/entity-processor/base-entity-processor.js

@@ -133,6 +133,8 @@ class BaseEntityProcessor {
                 return await this.handleOutgoingUpsert(entityType, event);
             case 'delete':
                 return await this.handleOutgoingDelete(entityType, event);
+            case 'sendUpsertToFlexPLM':
+                return await this.sendUpsertToFlexPLM(event);
             default:
                 console.log(UNSUPPORTED_TYPE);
                 return {
@@ -171,5 +173,38 @@ class BaseEntityProcessor {
     async handleOutgoingDelete(entityType, event) {
         console.warn('delete is not configured', entityType, event.oldData);
     }
+    async triggerSendEvent(triggerKey, event) {
+        const newEvent = {
+            entityName: 'event-workflow-request',
+            object: {
+                triggerKey,
+                event
+            }
+        };
+        const response = await this.entities.create(newEvent);
+        return response;
+    }
+    async sendUpsertToFlexPLM(event) {
+        const payload = await this.getEntityUpsertPayload(event);
+        if (!payload) {
+            const message = 'No payload to send to FlexPLM';
+            console.log(message);
+            return {
+                status: 500,
+                data: { message }
+            };
+        }
+        ;
+        const flexResponse = await new flexplm_connect_1.FlexPLMConnect(this.config).sendToFlexPLM(payload);
+        const outboundEntityUpdates = await this.getOutboundEntityUpdates(event, flexResponse);
+        if (outboundEntityUpdates) {
+            flexResponse['outboundEntityUpdates'] = outboundEntityUpdates;
+        }
+        return flexResponse;
+    }
+    async getEntityUpsertPayload(event) {
+        console.warn('getEntityUpsertPayload is not configured', JSON.stringify(event));
+        return undefined;
+    }
 }
 exports.BaseEntityProcessor = BaseEntityProcessor;

package/lib/util/map-utils.d.ts

@@ -1,6 +1,6 @@
 import { MapFileUtil } from '@contrail/transform-data';
 export declare class MapUtil {
-    static applyTransformMap(transformMapFile: any, mapFileUtil: any, data: any, mapSectionKey: string, direction: string): Promise<any>;
+    static applyTransformMap(transformMapFile: any, mapFileUtil: any, data: any, mapSectionKey: string, direction: string, transformTaskOrderKey?: string): Promise<any>;
     static getMapKey(transformMapFile: any, mapFileUtil: MapFileUtil, data: any, type: string, direction: string): Promise<string>;
     static getFullMapSection(transformMapFile: string, mapFileUtil: MapFileUtil, mapSectionKey: string): Promise<any>;
 }

package/lib/util/map-utils.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MapUtil = void 0;
 class MapUtil {
-    static async applyTransformMap(transformMapFile, mapFileUtil, data, mapSectionKey, direction) {
-        return await mapFileUtil.applyTransformMap(transformMapFile, data, mapSectionKey, direction);
+    static async applyTransformMap(transformMapFile, mapFileUtil, data, mapSectionKey, direction, transformTaskOrderKey = 'transformOrder') {
+        return await mapFileUtil.applyTransformMap(transformMapFile, data, mapSectionKey, direction, transformTaskOrderKey);
     }
     static async getMapKey(transformMapFile, mapFileUtil, data, type, direction) {
         return await mapFileUtil.getMapKey(transformMapFile, data, type, direction);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/flexplm",
-  "version": "1.1.35",
+  "version": "1.1.37",
   "description": "Library used for integration with flexplm.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -40,7 +40,7 @@
   "dependencies": {
     "@contrail/app-framework": "^1.2.4",
     "@contrail/sdk": "^1.3.7",
-    "@contrail/transform-data": "^1.0.14",
+    "@contrail/transform-data": "^1.0.15",
     "axios": "^1.4.0",
     "p-limit": "^3.1.0"
   }

package/src/entity-processor/base-entity-processor.ts

@@ -176,6 +176,8 @@ export abstract class BaseEntityProcessor {
       return await this.handleOutgoingUpsert(entityType, event);
     case 'delete':
       return await this.handleOutgoingDelete(entityType, event);
+    case 'sendUpsertToFlexPLM':
+      return await this.sendUpsertToFlexPLM(event);
     default:
       console.log(UNSUPPORTED_TYPE);
       return {
@@ -223,4 +225,57 @@ export abstract class BaseEntityProcessor {
 
   // This method must be implemented by derived classes
   protected abstract getOutgoingUpsertPayload(entityType, event): Promise<EntityPayloadType>;
+
+  /** Create a new event-workflow-request to rerun sending the entity to FlexPLM
+   * The event must contain any information needed to ensure it is put in the correct queue for the entity
+   *
+   * @param triggerKey Ex: event.entityType + '|sendUpsertToFlexPLM'
+   * @param event
+   * @returns
+   */
+
+  protected async triggerSendEvent(triggerKey: string, event: any) {
+    const newEvent = {
+      entityName: 'event-workflow-request',
+      object: {
+        triggerKey,
+        event
+      }
+  };
+  const response = await this.entities.create(newEvent);
+
+    return response;
+  }
+
+  /** Sends the current state of the entity to FlexPLM.
+   * So any changes made in Vibe between the event being generated and the event being processed are sent to FlexPLM.
+   *
+   * @param event must contain entityType, id; which are used to query for the entity
+   * @returns results of sending the entity to FlexPLM
+   */
+  protected async sendUpsertToFlexPLM(event) {
+    const payload = await this.getEntityUpsertPayload(event);
+    if(!payload){
+      const message = 'No payload to send to FlexPLM';
+      console.log(message);
+      return {
+        status: 500,
+        data: {message}
+      };
+    };
+    const flexResponse: any = await new FlexPLMConnect(this.config).sendToFlexPLM(payload);
+
+    const outboundEntityUpdates = await this.getOutboundEntityUpdates(event, flexResponse);
+    if(outboundEntityUpdates){
+      flexResponse['outboundEntityUpdates'] = outboundEntityUpdates;
+    }
+
+    return flexResponse;
+
+  }
+
+  protected async getEntityUpsertPayload(event: any): Promise<EntityPayloadType> {
+    console.warn('getEntityUpsertPayload is not configured', JSON.stringify(event));
+    return undefined;
+  }
 }

package/src/util/map-utils.ts

@@ -1,4 +1,4 @@
-import { MapFileUtil, TransformProcessor, TransformTask } from '@contrail/transform-data';
+import { MapFileUtil } from '@contrail/transform-data';
 export class MapUtil {
     /** Transforms the data, assumes mapSectionKey has been correctly determined.
      *
@@ -7,10 +7,11 @@ export class MapUtil {
      * @param data
      * @param mapSectionKey key for section of map file
      * @param direction vibe2flex or flex2vibe
+     * @param transformTaskOrderKey key for the list of tasks to be processed. default is 'transformOrder'
      * @returns The converted data
      */
-    static async applyTransformMap(transformMapFile, mapFileUtil, data: any, mapSectionKey: string, direction: string) {
-        return await mapFileUtil.applyTransformMap(transformMapFile, data, mapSectionKey, direction);
+    static async applyTransformMap(transformMapFile, mapFileUtil, data: any, mapSectionKey: string, direction: string, transformTaskOrderKey: string = 'transformOrder'): Promise<any> {
+        return await mapFileUtil.applyTransformMap(transformMapFile, data, mapSectionKey, direction, transformTaskOrderKey);
     }
 
   /** Returns the mapKey based on the 'typeConversion' section of the map file.