@contrail/flexplm 1.1.13 → 1.1.14

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

@@ -0,0 +1,183 @@
+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 { TypeConversionUtils } from '../util/type-conversion-utils';
+
+const UNSUPPORTED_TYPE = 'Unsupported eventType.';
+export class IncomingEntityResponse {
+  entity: any
+  earlyReturn: any
+}
+
+export abstract class BaseEntityProcessor {
+  protected typeUtil: TypeUtils;
+  protected transformMapFile: string;
+  protected entities;
+  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();
+  }
+
+  // inbound
+  async inbound(event: EntityPayloadType) {
+    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.error(UNSUPPORTED_TYPE);
+      return {
+        status: 500,
+        data: { UNSUPPORTED_TYPE }
+      };
+    }
+  }
+
+  async handleIncomingUpdate (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) {
+      return incomingEntityResponse.earlyReturn;
+    }
+
+    const entity = incomingEntityResponse.entity;
+    if(!entity){
+      const message = 'No entity found';
+      console.debug(message);
+      return {
+        status: 404,
+        data: {message}
+      };
+    }
+
+    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 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(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) {
+      //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 updateEntity(entityName, entity, diffs) {
+    const options = {
+      entityName: entityName,
+      id: entity['id'],
+      object: diffs
+    };
+    console.log('options: ' + JSON.stringify(options));
+
+    return await new Entities().update(options);
+  }
+
+  // This method must be implemented by derived classes
+  protected abstract getIncomingEntity(event, 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);
+    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 FlexPLMConnect(this.config).sendToFlexPLM(payload);
+  }
+
+  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>;
+}

package/src/flexplm-request.ts

@@ -0,0 +1,28 @@
+import axios, { AxiosRequestConfig } from 'axios';
+
+const BASE_URL: string = 'https://PP-2006031951wo.portal.ptc.io/Windchill/servlet/rest/cdee';
+const BASE_CONFIG: AxiosRequestConfig = {
+  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',
+  },
+};
+
+export class FlexPLMRequest {
+  static async request(path: string, data: any){
+    const config = Object.assign({}, BASE_CONFIG);
+    config.url = BASE_URL + path;
+    config.data = data;
+    try {
+      const resp = await axios(config);
+      return Promise.resolve(resp.data);
+    } catch (error) {
+      console.error(`${FlexPLMRequest} error: ${error.message}`);
+      return Promise.resolve(null);
+    }
+  }
+}

package/src/flexplm-utils.spec.ts

@@ -0,0 +1,27 @@
+import { FlexPLMUtils } from './flexplm-utils';
+
+describe('Types Controller', () => {
+
+  beforeEach(async () => {
+  });
+
+  it('should convert a type path', () => {
+    expect(FlexPLMUtils.convertTypePath('Product')).toEqual('product');
+    expect(FlexPLMUtils.convertTypePath('Product\\Apparel')).toEqual('product:apparel');
+    expect(FlexPLMUtils.convertTypePath('Product\\Skin Care')).toEqual('product:skin_care');
+    expect(FlexPLMUtils.convertTypePath('Product\\Apparel\\Shirt')).toEqual('product:apparel:shirt');
+    expect(FlexPLMUtils.convertTypePath('Product\\Apparel\\[Shirt]')).toEqual('product:apparel:*shirt*');
+    expect(FlexPLMUtils.convertTypePath('')).toBeNull();
+  });
+  it('should compute level in tree', () => {
+    expect(FlexPLMUtils.computeLevelFromPath('product')).toEqual(1);
+    expect(FlexPLMUtils.computeLevelFromPath('product:apparel')).toEqual(2);
+    expect(FlexPLMUtils.computeLevelFromPath('product:apparel:dress:mini')).toEqual(4);
+  });
+  it('should get a parent type path', () => {
+    expect(FlexPLMUtils.getParentTypePath('product')).toBeNull();
+    expect(FlexPLMUtils.getParentTypePath('product:apparel')).toEqual('product');
+    expect(FlexPLMUtils.getParentTypePath('product:apparel:stuff')).toEqual('product:apparel');
+    expect(FlexPLMUtils.getParentTypePath('Product\\Apparel')).toEqual('product');
+  });
+});

package/src/flexplm-utils.ts

@@ -0,0 +1,29 @@
+export class FlexPLMUtils {
+  static convertTypePath = (path: string): string => {
+    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;
+  }
+
+  static getParentTypePath = (path: string): string => {
+    const newPath = FlexPLMUtils.convertTypePath(path);
+    return (!newPath || newPath.indexOf(':') < 0) ? null : newPath.substring(0, newPath.lastIndexOf(':'));
+  }
+
+  static computeLevelFromPath(path: string) {
+    return (path.match(/:/g) || []).length + 1;
+  }
+}

package/src/index.ts

@@ -0,0 +1,20 @@
+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 './interfaces/interfaces';
+export * from './util/logger-config';
+export * from './util/thumbnail-util';
+export * from './util/type-conversion-utils';
+export * from './util/type-defaults';
+export * from './util/type-utils';
+export * from './util/map-utils';
+export * from './interfaces/interfaces';
+export * from './interfaces/item-family-changes';
+export * from './interfaces/publish-change-data';
+export * from './publish/base-process-publish-assortment';
+export * from './publish/base-process-publish-assortment-callback';
+export * from './entity-processor/base-entity-processor';
+export * from './transform/identifier-conversion';

package/src/interfaces/interfaces.ts

@@ -0,0 +1,120 @@
+export interface FCConfig {
+    apiKey?: string;
+    orgSlug?: string;
+    action?: string;
+    configFile? :string;
+    eventObjectClassParam?: string;
+    eventFlexTypePathParam?: string;
+    flexplmConnect?: any;
+    taskId?: string;
+    apiHost: string;
+    userName(): string;
+    password(): string;
+    plmEnviornment?: string;
+    urlContext: string;
+    vibeEventEndpoint: string;
+    csrfEndpoint: string;
+    itemPreDevelopmentLifecycleStages: string[];
+    identifierAtts?: {
+        [key:string]: string[]
+    };
+    propertyMapping?: object;
+}
+
+export interface ProductFederation {
+    entityReference: string;
+    objectClass: 'LCSProduct';
+    federatedId?: string;
+    flexPLMTypePath?: string;
+    vibeIQIdentifier?: string
+}
+export interface ProductData extends ProductFederation {
+    data: object;
+    productSeason: {
+        data: object;
+    }
+}
+
+export interface SeasonFederation {
+    entityReference: string;
+    objectClass: 'LCSSeason';
+    flexPLMSeasonName?: string;
+    federationId?: string;
+    flexPLMTypePath?: string;
+}
+
+export interface SeasonGroupFederation {
+    entityReference: string;
+    objectClass: 'SeasonGroup';
+    seasonGroupName?: string;
+    federationId?: string;
+    flexPLMTypePath?: string;
+}
+
+export interface SkuFederation {
+    entityReference: string;
+    objectClass: 'LCSSKU';
+    LCSProduct?: ProductFederation;
+    federatedId?: string;
+    flexPLMTypePath?: string;
+    vibeIQIdentifier?: string;
+}
+export interface SkuData extends SkuFederation{
+    data: object;
+}
+
+export interface PayloadType {
+    eventType: string;
+    objectClass: string;
+}
+export interface AsyncPayloadType extends PayloadType {
+    taskId: string;
+}
+export interface AsyncEventsPayloadType extends AsyncPayloadType {
+    events?: PayloadType[];
+    eventsFileId?: string;
+    eventsDownloadLink?: string;
+}
+
+export interface EntityPayloadType extends PayloadType {
+    entityReference: string;
+    federatedId?: string;
+    flexPLMTypePath?: string;
+    data: object;
+}
+
+export interface ItemPayloadType extends EntityPayloadType {
+    LCSProduct?: ProductFederation;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+///////// Custom seasonalPayload: start
+/////////////////////////////////////////////////////////////////////////////
+export interface SeasonalPayload extends EntityPayloadType {
+    eventType: 'UPSERT_ON_SEASON' | 'REMOVE_FROM_SEASON';
+    objectClass: 'LCSProductSeasonLink' | 'LCSSKUSeasonLink';
+    LCSSeason : SeasonFederation;
+    LCSProduct? : ProductFederation;
+    LCSSKU? : SkuFederation;
+    carriedFromSeason? : object;
+}
+/////////////////////////////////////////////////////////////////////////////
+///////// Custom seasonalPayload: start
+/////////////////////////////////////////////////////////////////////////////
+
+export interface ExportPayloadType extends AsyncPayloadType {
+    flexPLMTypePath: string;
+}
+
+export interface FederationRecord {
+    reference: string;
+    mappedReference: string
+    appIdentifier: string;
+    federationSchema: string
+}
+
+export interface FlexPLMResponseData {
+    status: number;
+    data?: object;
+    error?: string;
+}

package/src/interfaces/item-family-changes.ts

@@ -0,0 +1,67 @@
+export class ItemFamilyChanges {
+  private _itemFamilyId:string;
+  public get itemFamilyId(){ return this._itemFamilyId; }
+  private _sinceDate:Date;
+  public get sinceDate(){ return this._sinceDate; }
+
+  familyAdd = false;
+  familyDelete = false;
+  familyUpdate = false;
+  familyItemRemoved = false;
+  itemFamilyObject = undefined;
+
+  colorAdds: string[] = [];
+  colorDeletes: string[] = [];
+  colorUpdates: string[] = [];
+  colorUnchanged: string[] = [];
+
+  assortmentItemFullChangeMap = new Map<string, any>();
+  assortmentItemDeleteMap = new Map<string, any>();
+  itemToFederatedIdMapping = new Map<string, string>();
+  constructor(itemFamilyId: string, sinceDate: Date){
+    this._itemFamilyId = itemFamilyId;
+    this._sinceDate = sinceDate;
+  }
+
+  public toString(): string{
+    let s = 'ItemFamilyChanges\n'
+      + ' itemFamilyId: ' + this._itemFamilyId + '\n'
+      + ' sinceDate: ' + this._sinceDate + '\n'
+      + ' familyAdd: ' + this.familyAdd + '\n'
+      + ' familyDelete: ' + this.familyDelete + '\n'
+      + ' familyUpdate: ' + this.familyUpdate + '\n'
+      + ' familyItemRemoved: ' + this.familyItemRemoved + '\n'
+    ;
+
+    s += ' colorAdds: ['+ this.colorAdds + ']\n';
+
+    s += ' colorDeletes: ['+ this.colorDeletes + ']\n';
+
+    s += ' colorUpdates: ['+ this.colorUpdates + ']\n';
+
+    s += ' colorUnchanged: ['+ this.colorUnchanged + ']\n';
+
+    s += 'assortmentItemFullChangeMap:\n';
+    s += 'size: ' + this.assortmentItemFullChangeMap.size +'\n[';
+    for(const key of this.assortmentItemFullChangeMap.keys()){
+      s += key + ', ';
+    }
+    s += ']\n';
+
+    s += 'assortmentItemDeleteMap:\n';
+    s += 'size: ' + this.assortmentItemDeleteMap.size +'\n[';
+    for(const key of this.assortmentItemDeleteMap.keys()){
+      s += key + ', ';
+    }
+    s += ']\n';
+
+    s += 'itemToFederatedIdMapping:\n';
+    s += 'size: ' + this.itemToFederatedIdMapping.size +'\n[';
+    for(const key of this.itemToFederatedIdMapping.keys()){
+      s += key + ', ';
+    }
+    s += ']\n';
+
+    return s;
+  }
+}

package/src/interfaces/publish-change-data.ts

@@ -0,0 +1,43 @@
+import { SeasonFederation } from './interfaces';
+import { ItemFamilyChanges } from './item-family-changes';
+
+export class PublishChangeData {
+
+  private _assortmentId: string;
+  public get assortmentId(){ return this._assortmentId; }
+  private _seasonFed: SeasonFederation;
+  public get seasonFed() { return Object.assign({}, this._seasonFed); }
+  private _assortmentPublishChangeId: string;
+  public get assortmentPublishChangeId() { return this._assortmentPublishChangeId; }
+  private _sinceDate: Date;
+  public get sinceDate(){ return this._sinceDate; }
+  private _publisher: object;
+  public get publisher(){ return this._publisher; }
+
+  itemToFederatedIdMapping: Map<string, string>;
+  releasedForDevelopmentItemIds: string[] = [];
+  itemFamilyChanges = new Map<string, ItemFamilyChanges>();
+  constructor(_assortmentId: string, _seasonFed: SeasonFederation, _assortmentPublishChangeId: string, _sinceDate: Date, _publisher = {}) {
+    this._assortmentId = _assortmentId;
+    this._seasonFed = _seasonFed;
+    this._assortmentPublishChangeId = _assortmentPublishChangeId;
+    this._sinceDate = _sinceDate;
+    this._publisher = _publisher;
+  }
+
+  toString(){
+    let s = 'PublishChangeData\n'
+      + 'assortmentId: ' + this._assortmentId + '\n'
+      + 'seasonFed: ' + JSON.stringify(this._seasonFed) + '\n'
+      + 'assortmentPublishChangeId: ' + this._assortmentPublishChangeId + '\n'
+      ;
+
+    s += ' itemToFederatedIdMapping: ' + JSON.stringify(Object.fromEntries(this.itemToFederatedIdMapping)) + '\n';
+    s += 'itemFamilyChanges:\n';
+    for(const [key, value] of this.itemFamilyChanges){
+      s += ' ' + key + ' => ' + value.toString();
+    }
+    return s;
+  }
+
+}

package/src/publish/base-process-publish-assortment-callback.ts

@@ -0,0 +1,23 @@
+import { FCConfig } from '../interfaces/interfaces';
+
+export class BaseProcessPublishAssortmentCallback {
+  private config: FCConfig;
+
+  constructor(_config:FCConfig){
+    this.config = _config;
+  }
+
+  public async process(event){
+    console.log('ProcessPublishAssortmentCallback-process()');
+
+    console.log('ProcessPublishAssortmentCallback-event: ' + JSON.stringify(event));
+    console.log('ProcessPublishAssortmentCallback-config: ' + JSON.stringify(this.config));
+
+    const statusCounts = this.config['statusCounts'];
+    console.log('statusCounts: ' + JSON.stringify(statusCounts));
+    return {
+      message: 'Done ProcessPublishAssortmentCallback-process()'
+    };
+  }
+
+}