@contrail/flexplm 1.1.41 → 1.1.42

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 triggerNewEvent(triggerKey: string, event: any): Promise<any>;
+    protected sendUpsertToFlexPLM(event: any): Promise<any>;
+    protected getEntityCurrentStateUpsertPayload(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,51 @@ class BaseEntityProcessor {
     async handleOutgoingDelete(entityType, event) {
         console.warn('delete is not configured', entityType, event.oldData);
     }
+    async triggerNewEvent(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.getEntityCurrentStateUpsertPayload(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 getEntityCurrentStateUpsertPayload(event) {
+        const id = event.id;
+        if (!id) {
+            return undefined;
+        }
+        const entity = await this.entities.get({
+            entityName: this.baseType,
+            id
+        });
+        if (!entity) {
+            return undefined;
+        }
+        event.newData = entity;
+        event.oldData = entity;
+        const payload = await this.getOutgoingUpsertPayload(this.baseType, event);
+        return payload;
+    }
 }
 exports.BaseEntityProcessor = BaseEntityProcessor;

package/package.json

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

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,82 @@ 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 triggerNewEvent(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.getEntityCurrentStateUpsertPayload(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;
+
+  }
+
+  /** Generates the payload to send to FlexPLM, based on the current state of the entity.
+   * The current state of the entity are used as the newData and oldData; which is passed
+   * to getOutgoingUpsertPayload to generate the payload.
+   * @param event information about the item to send to FlexPLM
+   * @returns The payload to send to FlexPLM
+   */
+  protected async getEntityCurrentStateUpsertPayload(event: any): Promise<EntityPayloadType> {
+
+    const id = event.id;
+    if(!id){
+      return undefined;
+    }
+
+    const entity = await this.entities.get({
+      entityName: this.baseType,
+      id
+    });
+
+    if(!entity){
+      return undefined;
+    }
+
+    event.newData = entity;
+    event.oldData = entity;
+
+    const payload = await this.getOutgoingUpsertPayload(this.baseType, event);
+
+    return payload;
+  }
 }