@contrail/flexplm 1.1.64 → 1.1.66

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

@@ -1,483 +1,486 @@
-import { FCConfig, EntityPayloadType } from '../interfaces/interfaces';
-import { DataConverter } from '../util/data-converter';
-import { TypeUtils } from '../util/type-utils';
-import { FlexPLMConnect,} from '../util/flexplm-connect';
-import { MapUtil } from '../util/map-utils';
-import { MapFileUtil } from '@contrail/transform-data';
-import { Entities } from '@contrail/sdk';
-import { TypeProperty } from '@contrail/types';
-import { TypeConversionUtils } from '../util/type-conversion-utils';
-import { EventShortMessageStatus } from '../util/event-short-message-status';
-
-const UNSUPPORTED_TYPE = 'Unsupported eventType.';
-export class IncomingEntityResponse {
-  entity: any
-  earlyReturn: any
-}
-
-export abstract class BaseEntityProcessor {
-
-  protected typeUtil: TypeUtils;
-  protected transformMapFile: string;
-  protected entities;
-  protected orgSlug: string;
-  constructor(
-    protected config: FCConfig,
-    protected dc: DataConverter,
-    protected mapFileUtil: MapFileUtil,
-    protected baseType: string
-  ) {
-    this.typeUtil = new TypeUtils();
-    this.transformMapFile = this.config?.transformMapFile;
-    this.entities = new Entities();
-    this.orgSlug = this.config?.orgSlug || 'unset-orgSlug';
-  }
-
-  // inbound
-  async inbound(event: EntityPayloadType) {
-    const eventType = event.eventType;
-    console.log(`inbound entity: ${eventType}:${event.objectClass}`);
-
-    switch (eventType) {
-    case 'PERSIST':
-      return await this.handleIncomingUpsert(event);
-    case 'DELETE':
-      return await this.handleIncomingDelete(event);
-    default:
-      console.error(UNSUPPORTED_TYPE);
-      return {
-        status: 500,
-        data: { UNSUPPORTED_TYPE }
-      };
-    }
-  }
-
-  async handleIncomingUpsert (event: EntityPayloadType) {
-    const inboundData = await this.getTransformedData(event);
-    const incomingEntityResponse = await this.getIncomingEntity(event, inboundData);
-    // This case means there was an early return in the getIncomingEntity method
-    if (incomingEntityResponse.earlyReturn) {
-      const statusMsg = this.getInboundStatusMessage({
-        status: EventShortMessageStatus.FAILURE,
-        statusMessage: incomingEntityResponse.earlyReturn.shortStatusMessage || '',
-        objectClass: event.objectClass,
-        federatedId: event.federatedId
-      });
-      console.log(statusMsg);
-      return incomingEntityResponse.earlyReturn;
-    }
-
-    const entity = incomingEntityResponse.entity;
-    if (!entity) {
-      const createEntityResponse = await this.getCreateEntity(inboundData);
-      if (createEntityResponse.earlyReturn) {
-        const status = (createEntityResponse.earlyReturn.shortStatusMessage === EventShortMessageStatus.NOT_CREATABLE)
-          ? EventShortMessageStatus.SUCCESS
-          : EventShortMessageStatus.FAILURE;
-        const statusMsg = this.getInboundStatusMessage({
-          status,
-          statusMessage: createEntityResponse.earlyReturn.shortStatusMessage ||'',
-          objectClass: event.objectClass,
-          federatedId: event.federatedId
-        });
-        console.log(statusMsg);
-        return createEntityResponse.earlyReturn;
-      }
-      const createdEntity = await this.createEntity(this.baseType, createEntityResponse.entity);
-      const statusMsg = this.getInboundStatusMessage({
-        status: EventShortMessageStatus.SUCCESS,
-        statusMessage: EventShortMessageStatus.CREATED,
-        objectClass: event.objectClass,
-        entityId: 'id',
-        federatedId: event.federatedId
-      });
-      console.log(statusMsg);
-      return createdEntity;
-    }
-
-    const diffs = await this.getUpdatesForEntity(entity, inboundData);
-    if(Object.getOwnPropertyNames(diffs).length == 0){
-      const statusMsg = this.getInboundStatusMessage({
-        status: EventShortMessageStatus.SUCCESS,
-        statusMessage: EventShortMessageStatus.NO_CHANGES,
-        objectClass: event.objectClass,
-        entityId: entity.id,
-        federatedId: event.federatedId
-      });
-      console.log(statusMsg);
-      const message = 'No Changes to persist for entity: ' + entity.id;
-      return {
-        status: 200,
-        data: {message}
-      };
-    }
-
-    const updatedEntity  = await this.updateEntity(this.baseType, entity, diffs);
-    const statusMsg = this.getInboundStatusMessage({
-      status: EventShortMessageStatus.SUCCESS,
-      statusMessage: EventShortMessageStatus.UPDATED,
-      objectClass: event.objectClass,
-      entityId: entity.id,
-      federatedId: event.federatedId
-    });
-    console.log(statusMsg);
-    return updatedEntity;
-  }
-
-  getInboundStatusMessage(statusObject){
-    return 'BaseEntityProcessor: inbound: status: ' + statusObject.status
-    + ', statusMessage: ' + statusObject.statusMessage
-    + ', entityType: ' + this.baseType
-    + ', entityId: ' + statusObject.entityId
-    + ', objectClass: ' + statusObject.objectClass
-    + ', federatedId: ' + statusObject.federatedId
-    + ', orgSlug: ' + this.orgSlug;
-  }
-
-  /**This will query for the entity, and handle post-processing
-   * of any critieria that is defined at the sub-type level.
-   * Because sub-type criteria can't be used in the search done
-   * on the server. This is expected to be called by getIncomingEntity().
-   *
-   * @param entityType: the root type of the entity
-   * @param entityTypePath: the full type path of the entity. Ex: custom-entity:sample
-   * @param propertyCriteria: all the criteria to search for the entity
-   * @returns the entities that match the criteria
-   */
-  async queryEntityWithSubTypeCriteria(entityType: string, entityTypePath: string, propertyCriteria: any): Promise<any[]>{
-    //allCriteria; identifierKeys; entityType; entityTypePath
-    if(!entityType || !entityTypePath){
-      throw new Error('type and entityTypePath must be defined');
-    }
-    if(!propertyCriteria || Object.getOwnPropertyNames(propertyCriteria).length == 0){
-      throw new Error('propertyCriteria must be defined and have at least one property');
-    }
-
-    const {rootTypeCriteria, subTypeCriteria} = await this.getCriteriaForEntity(entityType, entityTypePath, propertyCriteria);
-
-    const returnedEntities = await this.dc.getAllObjectReferences(entityType, rootTypeCriteria, subTypeCriteria);
-
-    return returnedEntities;
-  }
-
-  /** This is to get the criteria for the entity that is being processed.
-   * This is to be overridden for item & project-item because of the need for
-   * setting the roles criteria.
-   *
-   * @param entityType: the root type of the entity
-   * @param entityTypePath: the full type path of the entity. Ex: custom-entity:sample
-   * @param propertyCriteria: all the criteria to search for the entity
-   * @returns the criteria for the entity
-   */
-  async getCriteriaForEntity(entityType: string, entityTypePath: string, propertyCriteria: any): Promise<any>{
-    if(!entityType || !entityTypePath){
-      throw new Error('type and entityTypePath must be defined');
-    }
-    if(!propertyCriteria || Object.getOwnPropertyNames(propertyCriteria).length == 0){
-      throw new Error('propertyCriteria must be defined and have at least one property');
-    }
-    const rootType = await this.typeUtil.getByRootAndPath({root: entityType});
-    const rootTypePropertyKeys = await this.getRootTypePropertyKeys(rootType, propertyCriteria);
-
-    const rootTypeCriteria = {};
-    const subTypeCriteria = {};
-    if(entityType !== entityTypePath){
-      subTypeCriteria['typePath'] = entityTypePath;
-    }
-    for(const key in propertyCriteria){
-      if(rootTypePropertyKeys.includes(key)){
-        rootTypeCriteria[key] = propertyCriteria[key];
-      }else{
-        subTypeCriteria[key] = propertyCriteria[key];
-      }
-    }
-
-    return {rootTypeCriteria, subTypeCriteria};
-  }
-
-  /** This is to get the properties that are owned by the root type
-   * This needs to be overridded for multi-level types, such as item
-   * and project-item. And for those types, the propertyCriteria
-   * will be needed to determine the correct level.
-   *
-   * @param rootType: the full root type entity for the processed entity
-   * @param propertyCriteria: the criteria to determine the correct level (unused for single level types)
-   * @returns: string[] of the property keys
-   */
-  getRootTypePropertyKeys(rootType, propertyCriteria = null): string[] {
-    const props: TypeProperty[] = rootType['typeProperties'];
-    const rootTypePropertyKeys = props.map(prop => prop.slug);
-
-    return rootTypePropertyKeys;
-  }
-
-
-  async handleIncomingDelete(event) {
-    console.warn('delete is not configured', event);
-  }
-
-  async getTransformedData(event) {
-    let inboundData = event.data;
-    console.debug('inboundData: ' + JSON.stringify(inboundData));
-
-    const mapKey = await TypeConversionUtils.getMapKeyFromObject(this.transformMapFile, this.mapFileUtil, inboundData, TypeConversionUtils.FLEX2VIBE_DIRECTION);
-    inboundData = await MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, inboundData, mapKey, TypeConversionUtils.FLEX2VIBE_DIRECTION);
-    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(updates, 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 && entity) {
-      //Technically the transform is flex->vibe.  But the vibe entity being updated was passed in,
-      // so we use VIBE2FLEX_DIRECTION to get the mapKey
-      const mapKey = await TypeConversionUtils.getMapKey(this.transformMapFile, this.mapFileUtil, entity, TypeConversionUtils.VIBE2FLEX_DIRECTION);
-
-      const mapSection = await MapUtil.getFullMapSection(this.transformMapFile, this.mapFileUtil, mapKey);
-      vibeOwningKeys = mapSection?.vibeOwningKeys || [];
-    }
-    console.debug('vibeOwningKeys: ' + vibeOwningKeys);
-    return vibeOwningKeys;
-  }
-
-  async getVibeOwningKeysFromInbound(entity) {
-    let vibeOwningKeys = [];
-    if (this.transformMapFile && entity) {
-      const mapKey = await TypeConversionUtils.getMapKeyFromObject(this.transformMapFile, this.mapFileUtil, entity, TypeConversionUtils.FLEX2VIBE_DIRECTION);
-
-      const mapSection = await MapUtil.getFullMapSection(this.transformMapFile, this.mapFileUtil, mapKey);
-      vibeOwningKeys = mapSection?.vibeOwningKeys || [];
-    }
-    console.debug('vibeOwningKeys: ' + vibeOwningKeys);
-    return vibeOwningKeys;
-  }
-
-  async createEntity(entityName, changes) {
-    const options = {
-      entityName: entityName,
-      object: changes,
-    };
-    console.log("createEntity: " + JSON.stringify(options));
-
-    return await new Entities().create(options);
-  }
-
-  async updateEntity(entityName, entity, diffs) {
-    const options = {
-      entityName: entityName,
-      id: entity['id'],
-      object: diffs
-    };
-    console.log('updateEntity: ' + JSON.stringify(options));
-
-    return await new Entities().update(options);
-  }
-
-  // This method must be implemented by derived classes
-  protected abstract getIncomingEntity(event, inboundData): Promise<IncomingEntityResponse>;
-  protected abstract getCreateEntity(inboundData): Promise<IncomingEntityResponse>;
-
-  // outbound
-
-  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);
-    case 'sendUpsertToFlexPLM':
-      return await this.sendUpsertToFlexPLM(event);
-    default:
-      console.log(UNSUPPORTED_TYPE);
-      return {
-        status: 500,
-        data: { UNSUPPORTED_TYPE }
-      };
-    }
-  }
-
-  async handleOutgoingUpsert(entityType, event) {
-    const objectClass = await TypeConversionUtils.getObjectClass(this.transformMapFile, this.mapFileUtil, event.newData);
-    if (!objectClass) {
-      const message = 'ObjectClass must have a value.';
-      console.log(message);
-      return {
-        status: 500,
-        data: { message }
-      };
-    }
-
-    try {
-      const payload = await this.getOutgoingUpsertPayload(entityType, event);
-      const flexResponse: any = await new FlexPLMConnect(this.config).sendToFlexPLM(payload);
-
-      const outboundEntityUpdates = await this.getOutboundEntityUpdates(event, flexResponse);
-      if(outboundEntityUpdates){
-        flexResponse['outboundEntityUpdates'] = outboundEntityUpdates;
-      }
-
-      const statusMsg = 'BaseEntityProcessor: outbound: status: ' + EventShortMessageStatus.SUCCESS
-      + ', statusMessage: '+ flexResponse.status
-      + ', entityType: ' + this.baseType
-      + ', entityId: ' + event.id
-      + ', objectClass: ' + payload.objectClass
-      + ', updateFromResponse: ' + (( outboundEntityUpdates &&Object.keys(outboundEntityUpdates).length > 0)? 'true' : 'false')
-      + ', orgSlug: ' + this.orgSlug;
-     console.log(statusMsg);
-
-      return flexResponse;
-
-    } catch(e){
-      const statusMsg = 'BaseEntityProcessor: outbound: status: '+ EventShortMessageStatus.FAILURE
-      + ', statusMessage: ' + e.httpResponseStatus
-      + ', entityType: ' + this.baseType
-      + ', entityId: ' + event.id
-      + ', objectClass: ' + objectClass
-      + ', updateFromResponse: ' + 'false'
-      + ', orgSlug: ' + this.orgSlug;
-      console.log(statusMsg);
-      throw e;
-    }
-  }
-
-  async getOutboundEntityUpdates(event, flexResponse): Promise<any> {
-    const payload = flexResponse?.data?.payload;
-    const flexPayload = (payload)? payload[0] : undefined;
-    let outboundEntityUpdates = undefined;
-    if(flexPayload && 'OK' === flexPayload.status) {
-      const inboundData = await this.getTransformedData(flexPayload);
-      outboundEntityUpdates = await this.getUpdatesForEntity(event.newData, inboundData)
-    }
-    return outboundEntityUpdates;
-  }
-
-  async handleOutgoingDelete(entityType, event) {
-    console.warn('delete is not configured', entityType, event.oldData);
-  }
-
-  // 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}
-      };
-    };
-    let objectClass = payload.objectClass;
-    try {
-      const flexResponse: any = await new FlexPLMConnect(this.config).sendToFlexPLM(payload);
-
-      const outboundEntityUpdates = await this.getOutboundEntityUpdates(event, flexResponse);
-      if(outboundEntityUpdates){
-        flexResponse['outboundEntityUpdates'] = outboundEntityUpdates;
-      }
-
-      const statusMsg = 'BaseEntityProcessor: outbound: status: ' + EventShortMessageStatus.SUCCESS
-      + ', statusMessage: ' + flexResponse.status
-      + ', entityType: ' + this.baseType
-      + ', entityId: ' + event.id
-      + ', objectClass: ' + objectClass
-      + ', updateFromResponse: ' + ((outboundEntityUpdates &&Object.keys(outboundEntityUpdates).length > 0)? 'true' : 'false')
-      + ', orgSlug: ' + this.orgSlug;
-      console.log(statusMsg);
-      return flexResponse;
-    }catch(e){
-      const statusMsg = 'BaseEntityProcessor: outbound: status: '+ EventShortMessageStatus.FAILURE
-      + ', statusMessage: ' + e.httpResponseStatus
-      + ', entityType: ' + this.baseType
-      + ', entityId: ' + event.id
-      + ', objectClass: ' + objectClass
-      + ', updateFromResponse: ' + 'false'
-      + ', orgSlug: ' + this.orgSlug;
-      console.log(statusMsg);
-      throw e;
-    }
-  }
-
-  /** 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;
-  }
-}
+import { FCConfig, EntityPayloadType } from '../interfaces/interfaces';
+import { DataConverter } from '../util/data-converter';
+import { TypeUtils } from '../util/type-utils';
+import { FlexPLMConnect,} from '../util/flexplm-connect';
+import { MapUtil } from '../util/map-utils';
+import { MapFileUtil } from '@contrail/transform-data';
+import { Entities } from '@contrail/sdk';
+import { TypeProperty } from '@contrail/types';
+import { TypeConversionUtils } from '../util/type-conversion-utils';
+import { EventShortMessageStatus } from '../util/event-short-message-status';
+
+const UNSUPPORTED_TYPE = 'Unsupported eventType.';
+export class IncomingEntityResponse {
+  entity: any
+  earlyReturn: any
+}
+
+export abstract class BaseEntityProcessor {
+
+  protected typeUtil: TypeUtils;
+  protected transformMapFile: string;
+  protected entities;
+  protected orgSlug: string;
+  constructor(
+    protected config: FCConfig,
+    protected dc: DataConverter,
+    protected mapFileUtil: MapFileUtil,
+    protected baseType: string
+  ) {
+    this.typeUtil = new TypeUtils();
+    this.transformMapFile = this.config?.transformMapFile;
+    this.entities = new Entities();
+    this.orgSlug = this.config?.orgSlug || 'unset-orgSlug';
+  }
+
+  // inbound
+  async inbound(event: EntityPayloadType) {
+    const eventType = event.eventType;
+    console.log(`inbound entity: ${eventType}:${event.objectClass}`);
+
+    switch (eventType) {
+    case 'PERSIST':
+      return await this.handleIncomingUpsert(event);
+    case 'DELETE':
+      return await this.handleIncomingDelete(event);
+    default:
+      console.error(UNSUPPORTED_TYPE);
+      return {
+        status: 500,
+        data: { UNSUPPORTED_TYPE }
+      };
+    }
+  }
+
+  async handleIncomingUpsert (event: EntityPayloadType) {
+    const inboundData = await this.getTransformedData(event);
+    const incomingEntityResponse = await this.getIncomingEntity(event, inboundData);
+    // This case means there was an early return in the getIncomingEntity method
+    if (incomingEntityResponse.earlyReturn) {
+      const statusMsg = this.getInboundStatusMessage({
+        status: EventShortMessageStatus.FAILURE,
+        statusMessage: incomingEntityResponse.earlyReturn.shortStatusMessage || '',
+        objectClass: event.objectClass,
+        federatedId: event.federatedId
+      });
+      console.log(statusMsg);
+      return incomingEntityResponse.earlyReturn;
+    }
+
+    const entity = incomingEntityResponse.entity;
+    if (!entity) {
+      const createEntityResponse = await this.getCreateEntity(inboundData);
+      if (createEntityResponse.earlyReturn) {
+        const status = (createEntityResponse.earlyReturn.shortStatusMessage === EventShortMessageStatus.NOT_CREATABLE)
+          ? EventShortMessageStatus.SUCCESS
+          : EventShortMessageStatus.FAILURE;
+        const statusMsg = this.getInboundStatusMessage({
+          status,
+          statusMessage: createEntityResponse.earlyReturn.shortStatusMessage ||'',
+          objectClass: event.objectClass,
+          federatedId: event.federatedId
+        });
+        console.log(statusMsg);
+        return createEntityResponse.earlyReturn;
+      }
+      const createdEntity = await this.createEntity(this.baseType, createEntityResponse.entity);
+      const statusMsg = this.getInboundStatusMessage({
+        status: EventShortMessageStatus.SUCCESS,
+        statusMessage: EventShortMessageStatus.CREATED,
+        objectClass: event.objectClass,
+        entityId: 'id',
+        federatedId: event.federatedId
+      });
+      console.log(statusMsg);
+      return createdEntity;
+    }
+
+    const diffs = await this.getUpdatesForEntity(entity, inboundData);
+    if(Object.getOwnPropertyNames(diffs).length == 0){
+      const statusMsg = this.getInboundStatusMessage({
+        status: EventShortMessageStatus.SUCCESS,
+        statusMessage: EventShortMessageStatus.NO_CHANGES,
+        objectClass: event.objectClass,
+        entityId: entity.id,
+        federatedId: event.federatedId
+      });
+      console.log(statusMsg);
+      const message = 'No Changes to persist for entity: ' + entity.id;
+      return {
+        status: 200,
+        data: {message}
+      };
+    }
+
+    const updatedEntity  = await this.updateEntity(this.baseType, entity, diffs);
+    const statusMsg = this.getInboundStatusMessage({
+      status: EventShortMessageStatus.SUCCESS,
+      statusMessage: EventShortMessageStatus.UPDATED,
+      objectClass: event.objectClass,
+      entityId: entity.id,
+      federatedId: event.federatedId
+    });
+    console.log(statusMsg);
+    return updatedEntity;
+  }
+
+  getInboundStatusMessage(statusObject){
+    return 'BaseEntityProcessor: inbound: status: ' + statusObject.status
+    + ', statusMessage: ' + statusObject.statusMessage
+    + ', entityType: ' + this.baseType
+    + ', entityId: ' + statusObject.entityId
+    + ', objectClass: ' + statusObject.objectClass
+    + ', federatedId: ' + statusObject.federatedId
+    + ', orgSlug: ' + this.orgSlug;
+  }
+
+  /**This will query for the entity, and handle post-processing
+   * of any critieria that is defined at the sub-type level.
+   * Because sub-type criteria can't be used in the search done
+   * on the server. This is expected to be called by getIncomingEntity().
+   *
+   * @param entityType: the root type of the entity
+   * @param entityTypePath: the full type path of the entity. Ex: custom-entity:sample
+   * @param propertyCriteria: all the criteria to search for the entity
+   * @returns the entities that match the criteria
+   */
+  async queryEntityWithSubTypeCriteria(entityType: string, entityTypePath: string, propertyCriteria: any): Promise<any[]>{
+    //allCriteria; identifierKeys; entityType; entityTypePath
+    if(!entityType || !entityTypePath){
+      throw new Error('type and entityTypePath must be defined');
+    }
+    if(!propertyCriteria || Object.getOwnPropertyNames(propertyCriteria).length == 0){
+      throw new Error('propertyCriteria must be defined and have at least one property');
+    }
+
+    const {rootTypeCriteria, subTypeCriteria} = await this.getCriteriaForEntity(entityType, entityTypePath, propertyCriteria);
+
+    const returnedEntities = await this.dc.getAllObjectReferences(entityType, rootTypeCriteria, subTypeCriteria);
+
+    return returnedEntities;
+  }
+
+  /** This is to get the criteria for the entity that is being processed.
+   * This is to be overridden for item & project-item because of the need for
+   * setting the roles criteria.
+   *
+   * @param entityType: the root type of the entity
+   * @param entityTypePath: the full type path of the entity. Ex: custom-entity:sample
+   * @param propertyCriteria: all the criteria to search for the entity
+   * @returns the criteria for the entity
+   */
+  async getCriteriaForEntity(entityType: string, entityTypePath: string, propertyCriteria: any): Promise<any>{
+    if(!entityType || !entityTypePath){
+      throw new Error('type and entityTypePath must be defined');
+    }
+    if(!propertyCriteria || Object.getOwnPropertyNames(propertyCriteria).length == 0){
+      throw new Error('propertyCriteria must be defined and have at least one property');
+    }
+    const rootType = await this.typeUtil.getByRootAndPath({root: entityType});
+    const rootTypePropertyKeys = await this.getRootTypePropertyKeys(rootType, propertyCriteria);
+
+    const rootTypeCriteria = {};
+    const subTypeCriteria = {};
+    if(entityType !== entityTypePath){
+      subTypeCriteria['typePath'] = entityTypePath;
+    }
+    for(const key in propertyCriteria){
+      if(rootTypePropertyKeys.includes(key)){
+        rootTypeCriteria[key] = propertyCriteria[key];
+      }else{
+        subTypeCriteria[key] = propertyCriteria[key];
+      }
+    }
+
+    return {rootTypeCriteria, subTypeCriteria};
+  }
+
+  /** This is to get the properties that are owned by the root type
+   * This needs to be overridded for multi-level types, such as item
+   * and project-item. And for those types, the propertyCriteria
+   * will be needed to determine the correct level.
+   *
+   * @param rootType: the full root type entity for the processed entity
+   * @param propertyCriteria: the criteria to determine the correct level (unused for single level types)
+   * @returns: string[] of the property keys
+   */
+  getRootTypePropertyKeys(rootType, propertyCriteria = null): string[] {
+    const props: TypeProperty[] = rootType['typeProperties'];
+    const rootTypePropertyKeys = props.map(prop => prop.slug);
+
+    return rootTypePropertyKeys;
+  }
+
+
+  async handleIncomingDelete(event) {
+    console.warn('delete is not configured', event);
+  }
+
+  async getTransformedData(event) {
+    let inboundData = event.data;
+    console.debug('inboundData: ' + JSON.stringify(inboundData));
+
+    const mapKey = await TypeConversionUtils.getMapKeyFromObject(this.transformMapFile, this.mapFileUtil, inboundData, TypeConversionUtils.FLEX2VIBE_DIRECTION);
+    inboundData = await MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, inboundData, mapKey, TypeConversionUtils.FLEX2VIBE_DIRECTION);
+    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(updates, 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 && entity) {
+      //Technically the transform is flex->vibe.  But the vibe entity being updated was passed in,
+      // so we use VIBE2FLEX_DIRECTION to get the mapKey
+      const mapKey = await TypeConversionUtils.getMapKey(this.transformMapFile, this.mapFileUtil, entity, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+
+      const mapSection = await MapUtil.getFullMapSection(this.transformMapFile, this.mapFileUtil, mapKey);
+      vibeOwningKeys = mapSection?.vibeOwningKeys || [];
+    }
+    console.debug('vibeOwningKeys: ' + vibeOwningKeys);
+    return vibeOwningKeys;
+  }
+
+  async getVibeOwningKeysFromInbound(entity) {
+    let vibeOwningKeys = [];
+    if (this.transformMapFile && entity) {
+      const mapKey = await TypeConversionUtils.getMapKeyFromObject(this.transformMapFile, this.mapFileUtil, entity, TypeConversionUtils.FLEX2VIBE_DIRECTION);
+
+      const mapSection = await MapUtil.getFullMapSection(this.transformMapFile, this.mapFileUtil, mapKey);
+      vibeOwningKeys = mapSection?.vibeOwningKeys || [];
+    }
+    console.debug('vibeOwningKeys: ' + vibeOwningKeys);
+    return vibeOwningKeys;
+  }
+
+  async createEntity(entityName, changes) {
+    const options = {
+      entityName: entityName,
+      object: changes,
+    };
+    console.log("createEntity: " + JSON.stringify(options));
+
+    return await new Entities().create(options);
+  }
+
+  async updateEntity(entityName, entity, diffs) {
+    const options = {
+      entityName: entityName,
+      id: entity['id'],
+      object: diffs
+    };
+    console.log('updateEntity: ' + JSON.stringify(options));
+
+    return await new Entities().update(options);
+  }
+
+  // This method must be implemented by derived classes
+  protected abstract getIncomingEntity(event, inboundData): Promise<IncomingEntityResponse>;
+  protected abstract getCreateEntity(inboundData): Promise<IncomingEntityResponse>;
+
+  // outbound
+
+  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);
+    case 'sendUpsertToFlexPLM':
+      return await this.sendUpsertToFlexPLM(event);
+    default:
+      console.log(UNSUPPORTED_TYPE);
+      return {
+        status: 500,
+        data: { UNSUPPORTED_TYPE }
+      };
+    }
+  }
+
+  async handleOutgoingUpsert(entityType, event) {
+    const objectClass = await TypeConversionUtils.getObjectClass(this.transformMapFile, this.mapFileUtil, event.newData);
+    if (!objectClass) {
+      const message = 'ObjectClass must have a value.';
+      console.log(message);
+      return {
+        status: 500,
+        data: { message }
+      };
+    }
+
+    try {
+      const payload = await this.getOutgoingUpsertPayload(entityType, event);
+      const flexResponse: any = await new FlexPLMConnect(this.config).sendToFlexPLM(payload);
+
+      const outboundEntityUpdates = await this.getOutboundEntityUpdates(event, flexResponse);
+      if(outboundEntityUpdates){
+        flexResponse['outboundEntityUpdates'] = outboundEntityUpdates;
+      }
+
+      const statusMsg = 'BaseEntityProcessor: outbound: status: ' + EventShortMessageStatus.SUCCESS
+      + ', statusMessage: '+ flexResponse.status
+      + ', entityType: ' + this.baseType
+      + ', entityId: ' + event.id
+      + ', objectClass: ' + payload.objectClass
+      + ', updateFromResponse: ' + (( outboundEntityUpdates &&Object.keys(outboundEntityUpdates).length > 0)? 'true' : 'false')
+      + ', orgSlug: ' + this.orgSlug;
+     console.log(statusMsg);
+
+      return flexResponse;
+
+    } catch(e){
+      const statusMsg = 'BaseEntityProcessor: outbound: status: '+ EventShortMessageStatus.FAILURE
+      + ', statusMessage: ' + e.httpResponseStatus
+      + ', entityType: ' + this.baseType
+      + ', entityId: ' + event.id
+      + ', objectClass: ' + objectClass
+      + ', updateFromResponse: ' + 'false'
+      + ', orgSlug: ' + this.orgSlug;
+      console.log(statusMsg);
+      throw e;
+    }
+  }
+
+  async getOutboundEntityUpdates(event, flexResponse): Promise<any> {
+    const payload = flexResponse?.data?.payload;
+    const flexPayload = (payload)? payload[0] : undefined;
+    let outboundEntityUpdates = undefined;
+    if(flexPayload && 'OK' === flexPayload.status) {
+      if(flexPayload.data && !flexPayload.data?.flexPLMObjectClass){
+        flexPayload.data.flexPLMObjectClass = flexPayload.objectClass;
+      }
+      const inboundData = await this.getTransformedData(flexPayload);
+      outboundEntityUpdates = await this.getUpdatesForEntity(event.newData, inboundData)
+    }
+    return outboundEntityUpdates;
+  }
+
+  async handleOutgoingDelete(entityType, event) {
+    console.warn('delete is not configured', entityType, event.oldData);
+  }
+
+  // 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}
+      };
+    };
+    let objectClass = payload.objectClass;
+    try {
+      const flexResponse: any = await new FlexPLMConnect(this.config).sendToFlexPLM(payload);
+
+      const outboundEntityUpdates = await this.getOutboundEntityUpdates(event, flexResponse);
+      if(outboundEntityUpdates){
+        flexResponse['outboundEntityUpdates'] = outboundEntityUpdates;
+      }
+
+      const statusMsg = 'BaseEntityProcessor: outbound: status: ' + EventShortMessageStatus.SUCCESS
+      + ', statusMessage: ' + flexResponse.status
+      + ', entityType: ' + this.baseType
+      + ', entityId: ' + event.id
+      + ', objectClass: ' + objectClass
+      + ', updateFromResponse: ' + ((outboundEntityUpdates &&Object.keys(outboundEntityUpdates).length > 0)? 'true' : 'false')
+      + ', orgSlug: ' + this.orgSlug;
+      console.log(statusMsg);
+      return flexResponse;
+    }catch(e){
+      const statusMsg = 'BaseEntityProcessor: outbound: status: '+ EventShortMessageStatus.FAILURE
+      + ', statusMessage: ' + e.httpResponseStatus
+      + ', entityType: ' + this.baseType
+      + ', entityId: ' + event.id
+      + ', objectClass: ' + objectClass
+      + ', updateFromResponse: ' + 'false'
+      + ', orgSlug: ' + this.orgSlug;
+      console.log(statusMsg);
+      throw e;
+    }
+  }
+
+  /** 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;
+  }
+}