@contrail/flexplm 1.1.13 → 1.1.15

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

@@ -0,0 +1,1024 @@
+import { Entities, Files, Request } from '@contrail/sdk';
+import { AsyncEventsPayloadType, FCConfig, ProductFederation, SeasonalPayload, SeasonFederation, SkuFederation } from '../interfaces/interfaces';
+import { DataConverter } from '../util/data-converter';
+import { FlexPLMConnect } from '../util/flexplm-connect';
+import { ItemFamilyChanges } from '../interfaces/item-family-changes';
+import { PublishChangeData } from '../interfaces/publish-change-data';
+import { MapUtil } from '../util/map-utils';
+  
+import fsPromise = require('fs/promises');
+import path = require('path');
+import { MapFileUtil } from '@contrail/transform-data';
+import { Logger } from '@contrail/app-framework';
+import { TypeConversionUtils } from '../util/type-conversion-utils';
+
+export class BaseProcessPublishAssortment {
+
+  private TTL = 7 * 24 * 60 * 60 * 1_000; // 1 week
+  static ASSORTMENT_NOT_PUBLISHABLE = 'Assortment isn\'t marked for publishing to FlexPLM';
+  static ASSORTMENT_NO_FED_INFO = 'Assortment doesn\'t have all "identifier" properties or a federated id, so there is no processing. Identifier properties: ';
+  static NOT_ABLE_TO_PROCESS_DELETE_CHANGES = 'Error: Not able to process delete changes';
+  private dc: DataConverter;
+  private config: FCConfig;
+  private mapFileUtil: MapFileUtil;
+  private transformMapFile: string;
+  private cache = {
+    carriedFromSeason: {}
+  };
+  constructor(_config: FCConfig, _dc: DataConverter, _mapFileUtil: MapFileUtil) {
+    this.config = _config;
+    this.dc = _dc;
+    this.mapFileUtil = _mapFileUtil;
+    this.transformMapFile = this.config['transformMapFile'];
+  }
+
+  public async process(event) {
+    try {
+      console.info('process-start!');
+      const assortmentId = event.assortmentId;
+      let seasonFed: SeasonFederation;
+      try {
+        seasonFed = await this.getSeasonFederation(assortmentId);
+      } catch (e) {
+        const message = e.message;
+        console.log(message);
+        const output = {
+          results: { message },
+          skip_await: true
+        };
+        return output;
+      }
+
+      const assortmentPublishChangeId = event.assortmentPublishChangeId;
+      const apcHistory = await this.getApcHistory(assortmentId);
+      const sinceDate = await this.getSinceDate(assortmentId, assortmentPublishChangeId, apcHistory);
+
+      //Get detail information
+      const assortmentPublishChange = await this.downloadAssortmentPublishChange(assortmentId, assortmentPublishChangeId);
+
+      const changeDetail = await this.downloadHydratedChangeDetail(assortmentPublishChange);
+
+      const assortmentBaseline = await this.downloadAssortmentBaseline(assortmentPublishChange);
+
+      const deleteChanges = await this.getDeleteChanges(assortmentPublishChange, apcHistory, assortmentBaseline, sinceDate);
+
+      const releasedForDevelopmentItemIds = this.getReleasedForDevelopmentItemAndFamilyIds(assortmentBaseline, deleteChanges);
+      const itemToFederatedIdMapping = await this.getItemFederatedIds(/*allItemIds*/);
+
+      const publisher = this.getPublisher(assortmentPublishChange);
+      const pcd = new PublishChangeData(assortmentId, seasonFed, assortmentPublishChangeId, sinceDate, publisher);
+      pcd.itemToFederatedIdMapping = itemToFederatedIdMapping;
+
+      pcd.releasedForDevelopmentItemIds = releasedForDevelopmentItemIds;
+
+      const output = await this.processPublish(pcd, changeDetail, assortmentBaseline, deleteChanges);
+      console.info('process-end');
+
+      return output;
+    } catch (e) {
+      console.log('catch e: ' + e.message);
+      throw e;
+    }
+  }
+
+  async getSeasonFederation(assortmentId): Promise<SeasonFederation> {
+    let assortment;
+    try {
+      assortment = await new Entities().get({
+        entityName: 'assortment',
+        id: assortmentId
+      });
+      console.info('assortment-name: ' + assortment['name']);
+    } catch (e) {
+      console.warn(`No Assortment found for id: ${assortmentId}`);
+    }
+    const publishToFlexPLM = assortment?.publishToFlexPLM;
+    if (!publishToFlexPLM) {
+      throw new Error(BaseProcessPublishAssortment.ASSORTMENT_NOT_PUBLISHABLE);
+    }
+
+    const assortmentObj = await this.dc.getFlexPLMObjectData(assortment, [], true);
+    let seasonObj: any = {
+      entityReference: 'assortment:' + assortmentId,
+      objectClass: 'LCSSeason' as const,
+    };
+
+    const identifierKeys: string[] = this.config?.identifierAtts?.LCSSeason || [];
+    for (const key of identifierKeys) {
+      if (assortmentObj[key]) {
+        seasonObj[key] = assortmentObj[key];
+      }
+    }
+    const objectKeys = Object.keys(seasonObj);
+    const hasAllIdentifiers = identifierKeys.every(key => objectKeys.includes(key));
+
+    if (!hasAllIdentifiers && !seasonObj?.federationId) {
+      throw new Error(BaseProcessPublishAssortment.ASSORTMENT_NO_FED_INFO + identifierKeys);
+    }
+
+    seasonObj = await MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, seasonObj, 'LCSSeason', 'vibe2flex');
+    return seasonObj as SeasonFederation;
+  }
+
+  public async getSinceDate(assortmentId: any, assortmentPublishChangeId: any, apcHistory: object[]): Promise<Date> {
+
+    let sinceDate = null;
+
+    let pastPublishCount = 1;
+    if (this.config['sinceDate']) {
+      const sinceDateString = '' + this.config['sinceDate'];
+      if(sinceDateString && sinceDateString.indexOf('-') > 0){
+        const sinceDateParts = sinceDateString.split('-');
+        if(sinceDateParts.length == 3){
+          const year = parseInt(sinceDateParts[0]);
+          const month = parseInt(sinceDateParts[1]) - 1;
+          const day = parseInt(sinceDateParts[2]);
+          const minutes = 0 - new Date().getTimezoneOffset();
+          sinceDate = this.getSinceDateFromAPCSpecificDate(apcHistory, assortmentPublishChangeId, new Date(year, month, day, 0, minutes, 0));
+        }
+      } else if(sinceDateString && sinceDateString.indexOf(':') > 0){
+        const sinceDateParts = sinceDateString.split(':');
+        const type = sinceDateParts[0];
+        const count = parseInt(sinceDateParts[1]);
+        if('numberofdays' == type.toLocaleLowerCase()){
+          sinceDate = this.getSinceDateDaysPrevious(apcHistory, assortmentPublishChangeId, count);
+        } else if('numberofpublishes' == type.toLocaleLowerCase()){
+          pastPublishCount = count;
+        }
+
+      }
+    }
+
+    if(sinceDate == null) {
+      sinceDate = this.getSinceDateFromAPCs(apcHistory, assortmentPublishChangeId, pastPublishCount);
+    }
+    if(sinceDate == null){
+      throw new Error('Couldnt set sinceDate');
+    }
+    console.info('getSinceDate: ' + sinceDate);
+    return sinceDate;
+  }
+
+  async getApcHistory(assortmentId: any) {
+    const resource = `/assortments/${assortmentId}/history/`;
+    return Request.request(resource, {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
+      }
+    });
+  }
+
+  protected updatedSinceDate(entity, sinceDate: Date): boolean {
+    const updatedOn = entity?.updatedOn;
+    return (updatedOn && new Date(updatedOn) > sinceDate);
+  }
+
+  getSinceDateFromAPCSpecificDate(apcHistory: object[], assortmentPublishChangeId: string, specificDate: Date):Date {
+    const apc = apcHistory.find(apc => apc['id'] === assortmentPublishChangeId);
+    const apcDate = new Date(apc['createdOn']);
+    const dateArray = [];
+    for (const tempapc of apcHistory) {
+      if (assortmentPublishChangeId !== tempapc['id']) {
+        const tempDate = new Date(tempapc['createdOn']);
+        if (tempDate < apcDate) {
+          dateArray.push(tempDate);
+        }
+      }
+    }
+
+    dateArray.sort((a,b) => { return Date.parse(a) - Date.parse(b);});
+
+    let sinceDate = specificDate;
+
+    const sinceDateMilliseconds = sinceDate.getTime();
+    for(const d of dateArray){
+      const milli = Date.parse(d);
+      if(milli >= sinceDateMilliseconds){
+        sinceDate = d;
+        break;
+      }
+    }
+    return sinceDate;
+
+  }
+  getSinceDateDaysPrevious(apcHistory: object[], assortmentPublishChangeId: string, daysBack):Date {
+    const apc = apcHistory.find(apc => apc['id'] === assortmentPublishChangeId);
+    const apcDate = new Date(apc['createdOn']);
+    const dateArray = [];
+    for (const tempapc of apcHistory) {
+      if (assortmentPublishChangeId !== tempapc['id']) {
+        const tempDate = new Date(tempapc['createdOn']);
+        if (tempDate < apcDate) {
+          dateArray.push(tempDate);
+        }
+      }
+    }
+
+    dateArray.sort((a,b) => { return Date.parse(a) - Date.parse(b);});
+
+    let sinceDate = new Date(
+      apcDate.getUTCFullYear(),
+      apcDate.getUTCMonth(),
+      apcDate.getUTCDate()-daysBack,
+      0,
+      (0 - apcDate.getTimezoneOffset()),
+      0);
+
+    const sinceDateMilliseconds = sinceDate.getTime();
+    for(const d of dateArray){
+      const milli = Date.parse(d);
+      if(milli >= sinceDateMilliseconds){
+        sinceDate = d;
+        break;
+      }
+    }
+    return sinceDate;
+  }
+
+  getSinceDateFromAPCs(apcHistory: any[], assortmentPublishChangeId: string, pastPublishCount = 1): Date {
+    if(apcHistory.length === 1){
+      return new Date(0);
+    }
+    const apcIndex = apcHistory.findIndex(apc => apc.id === assortmentPublishChangeId);
+    if(apcIndex === 0){
+      return new Date(0);
+    }
+    const apc = apcHistory[apcIndex];
+    const apcDate = new Date(apc['createdOn']);
+    let sinceDate = new Date(0);
+    const dateArray = [];
+    for (const tempapc of apcHistory) {
+      if (assortmentPublishChangeId !== tempapc['id']) {
+        const tempDate = new Date(tempapc['createdOn']);
+        if (tempDate < apcDate) {
+          dateArray.push(tempDate);
+        }
+      }
+    }
+    dateArray.sort((a,b) => { return Date.parse(a) - Date.parse(b);});
+    const arrIndex = (dateArray.length - pastPublishCount > 0)? dateArray.length - pastPublishCount: 0;
+    sinceDate = dateArray[arrIndex];
+    return sinceDate;
+  }
+  protected getPublisher(assortmentPublishChange) {
+    const createdBy = assortmentPublishChange?.createdBy;
+    const publisher = {};
+    const includeKeys = ['email', 'firstName', 'isSsoUser', 'lastName'];
+    for(const [key, value] of Object.entries(createdBy)){
+      if(includeKeys.includes(key)){
+        publisher[key] = value;
+      }
+    }
+
+    return publisher;
+
+  }
+
+  async downloadAssortmentPublishChange(assortmentId: string, assortmentPublishChangeId: string) {
+    const resourceString = '/assortments/' + assortmentId + '/history/' + assortmentPublishChangeId;
+    return await Request.request(
+      resourceString,
+      {
+        method: 'GET',
+        Headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json'
+        }
+      }
+    );
+  }
+
+  async downloadHydratedChangeDetail(assortmentPublishChange) {
+    try {
+      console.info('downloadHydratedChangeDetail-start');
+      const link = assortmentPublishChange?.hydratedDetailDownloadLink;
+      const response = await fetch(link);
+      const data = await response.json();
+      return data;
+
+    } catch (e) {
+      console.log('Error hydratedDetailDownloadLink: ' + e.message);
+    }
+    return undefined;
+  }
+
+  async downloadAssortmentBaseline(assortmentPublishChange) {
+    console.info('downloadAssortmentBaseline-start');
+    try {
+      const link = assortmentPublishChange?.assortmentBaselineDownloadLink;
+      const response = await fetch(link);
+      const data = await response.json();
+      return data;
+
+    } catch (e) {
+      console.log('Error assortmentBaselineDownloadLink: ' + e.message);
+    }
+    return undefined;
+  }
+
+  async getDeleteChanges(assortmentPublishChange, apcHistory: object[], assortmentBaseline, sinceDate: Date): Promise<[]>{
+    console.info('getDeleteChanges(): ' + assortmentPublishChange['id']);
+    console.info(sinceDate);
+    const currentAPCIndex = apcHistory.findIndex(pc => pc['id'] === assortmentPublishChange['id']);
+    console.info(' currentAPCIndex: ' +  currentAPCIndex);
+    if(currentAPCIndex == 0){
+      return [];
+    }
+    const previousApcIndex = (currentAPCIndex > 0)? currentAPCIndex-1: 0;
+
+    const apcCreatedOn = apcHistory[previousApcIndex]['createdOn'];
+    console.info('apcCreatedOn:  ' + apcCreatedOn);
+    const apcDeletes = await this.downloadDeleteChanges(assortmentPublishChange);
+
+    let previousApcDate = Date.parse(apcCreatedOn);
+    const sinceDateMilliseconds = sinceDate.getTime();
+    if(Logger.isInfoOn()){
+      console.info('apcCreatedOn: ' + apcCreatedOn);
+      console.info('sinceDate: ' + sinceDate);
+      console.info('sinceDateMilliseconds: ' + sinceDateMilliseconds);
+      console.info('apcDateMilliseconds: ' + previousApcDate);
+    }
+    //if only 1 apc, no processing needed
+    if(sinceDateMilliseconds !== previousApcDate){
+      console.info('sinceDateMilliseconds !== apcDateMilliseconds');
+      const currentAssortmentItemIds = this.getBaselineItemIds(assortmentBaseline);
+      const deleteIds = (apcDeletes.length === 0)
+        ?[]
+        :apcDeletes.map(item => item['itemId']);
+      // console.log('currentAssortmentItemIds: ' + currentAssortmentItemIds);
+      // console.log('deleteIds: ' + deleteIds);
+
+      for(let i = currentAPCIndex -1; i > 0; i--) {
+        const workingAPC = apcHistory[i];
+        previousApcDate = Date.parse(workingAPC['createdOn']);
+        if(sinceDateMilliseconds === previousApcDate){
+          break;
+        }
+        if(workingAPC['deletes'] > 0){
+          const previousApc = (i > 0)
+            ?apcHistory[i-1]
+            :undefined;
+          const deleteChanges = await this.buildDeleteChanges(workingAPC, previousApc);
+          console.info('checking deleteChanges');
+          for(const dItem of deleteChanges){
+            const dItemId = dItem['itemId'];
+            console.info(dItemId);
+            if(!currentAssortmentItemIds.includes(dItemId) && !deleteIds.includes(dItemId)){
+              console.info('adding');
+              deleteIds.push(dItemId);
+              apcDeletes.push(dItem);
+            }
+          }
+        }
+      }
+      console.info('getDeleteChanges()-currentAssortmentItemIds: ' + currentAssortmentItemIds);
+      console.info('getDeleteChanges()-deleteIds: ' + deleteIds);
+    }
+
+    return apcDeletes;
+  }
+
+  getBaselineItemIds(assortmentBaseline): string[]{
+    const itemIds = [];
+    const assortmentItemsArray = assortmentBaseline['assortmentItems'];
+
+    for (const aItem of assortmentItemsArray) {
+      itemIds.push(aItem['itemId']);
+    }
+
+    return itemIds;
+  }
+
+  async downloadDeleteChanges(apc) {
+    console.info('deleteDataDownloadLink-start');
+    try {
+      const link = apc['deleteDataDownloadLink'];
+      // console.info('link: ' + link);
+      const response = await fetch(link);
+      // console.debug('Got deleteDataDownloadLink: ');
+      const data = await response.json();
+      // console.debug(JSON.stringify(data));
+      return data;
+
+    } catch (e) {
+      console.log('Error deleteDataDownloadLink: ' + e.message);
+    }
+    return undefined;
+  }
+
+  async buildDeleteChanges(apc, previousApc) {
+    console.info('buildDeleteChanges()');
+
+    if(apc['deleteDataDownloadLink']){
+      const deleteChanges =  await this.downloadDeleteChanges(apc);
+      if(deleteChanges){
+        return deleteChanges;
+      }
+    }
+    console.info('pulling down full APC');
+    apc = await this.downloadAssortmentPublishChange(apc['assortmentId'], apc['id']);
+    if(apc['deleteDataDownloadLink']){
+      const deleteChanges =  await this.downloadDeleteChanges(apc);
+      if(deleteChanges){
+        return deleteChanges;
+      }
+    }
+    if(!previousApc){
+      throw new Error(BaseProcessPublishAssortment.NOT_ABLE_TO_PROCESS_DELETE_CHANGES);
+    }
+
+    let previousBaseline;
+    console.info('check previousApc');
+    if(previousApc['assortmentBaselineDownloadLink']){
+      previousBaseline = await this.downloadAssortmentBaseline(previousApc);
+    }else {
+      console.info('previousApc pulling down full APC');
+      previousApc = await this.downloadAssortmentPublishChange(previousApc['assortmentId'], previousApc['id']);
+      previousBaseline = await this.downloadAssortmentBaseline(previousApc);
+    }
+
+    const deleteIds = apc['detail']['deletes'].map(dItem => dItem['id']);
+
+    //building deletes based on previous baseline; because some APCs don't have delete data
+    const deleteArray = previousBaseline['assortmentItems'].filter(aItem => deleteIds.includes(aItem['itemId']));
+    console.info('deleteArray.length: ' + deleteArray.length);
+    return deleteArray;
+  }
+
+  async getItemFederatedIds(/*itemIds*/): Promise<Map<string, string>> {
+
+    const itemFederatedIds = new Map<string, string>();
+    // const expandedItemIds = itemIds.map(id => 'item:' + id);
+    // const fedRecords = await new Federation(this.logger).getFederationRecordsFromIdsBulk(expandedItemIds);
+    // for (let i = 0; i < fedRecords.length; i++) {
+    //   const federationRecord = fedRecords[i];
+    //   // console.log('federationRecord: ' + JSON.stringify(federationRecord));
+    //   // console.log('federationRecord.reference: ' + federationRecord.reference);
+    //   // console.log('federationRecord.mappedReference: ' + federationRecord.mappedReference);
+    //   let vibeId = federationRecord.reference;
+    //   if (vibeId && vibeId.startsWith('item:')) {
+    //     vibeId = vibeId.substring(5);
+    //   }
+    //   itemFederatedIds.set(vibeId, federationRecord.mappedReference);
+    // }
+    // console.log('itemFederatedIds: ' + JSON.stringify(Object.fromEntries(itemFederatedIds)));
+    return itemFederatedIds;
+  }
+
+  getFullChangeAssortmentMap(fullChange: any): Map<string, object> {
+    const assortmentItemsArray = fullChange?.assortmentItems || [];
+    const assortmentItemsMap = new Map<string, object>();
+
+    for (const aItem of assortmentItemsArray) {
+      const itemId = aItem?.itemId;
+      assortmentItemsMap.set(itemId, aItem);
+    }
+
+    return assortmentItemsMap;
+  }
+
+  getDeleteChangesAssortmentMap(deleteChanges: any[]): Map<string, object> {
+    const deleteItems = new Map<string, object>();
+
+    for (const dItem of deleteChanges) {
+      deleteItems.set(dItem['itemId'], dItem);
+    }
+
+    return deleteItems;
+  }
+
+  getReleasedForDevelopmentItemAndFamilyIds(fullChange, deleteChanges): string[] {
+    console.info('getReleasedForDevelopmentItemAndFamilyIds');
+    const releasedForDevelopmentItemIds:string[] = [];
+    const itemFamilySet = new Set<string>();
+    const assortmentItemsArray = fullChange['assortmentItems'];
+
+    for (const aItem of assortmentItemsArray) {
+      const meetsCriteria= this.meetsCriteria(aItem);
+      const item = aItem['item'];
+      const itemId = item['id'];
+      const itemFamilyId = item['itemFamilyId'];
+      console.debug('itemId: ' + item['id']);
+      if(meetsCriteria){
+        console.debug('adding item to releasedForDevelopmentItemIds');
+        console.debug('itemFamilyId: ' + item['itemFamilyId']);
+        releasedForDevelopmentItemIds.push(itemId);
+        if(!itemFamilySet.has(itemFamilyId) && itemId !== itemFamilyId){
+          const familyItem = item['itemFamily'];
+          const familyItemMeetsCriteria = this.meetsCriteria({item: familyItem});
+          if(familyItemMeetsCriteria){
+            releasedForDevelopmentItemIds.push(itemFamilyId);
+          }
+          itemFamilySet.add(itemFamilyId);
+        }
+      }
+    }
+
+    for(const dItem of deleteChanges){
+      const meetsCriteria = this.meetsCriteria(dItem);
+      const item = dItem['item'];
+      const itemId = item['id'];
+      const itemFamilyId = item['itemFamilyId'];
+      console.debug('itemId: ' + item['id']);
+      if(meetsCriteria) {
+        releasedForDevelopmentItemIds.push(itemId);
+        if(!itemFamilySet.has(itemFamilyId) && itemId !== itemFamilyId){
+          const familyItem = item['itemFamily'];
+          if(familyItem){
+            const familyItemMeetsCriteria = this.meetsCriteria({item: familyItem});
+            if(familyItemMeetsCriteria){
+              releasedForDevelopmentItemIds.push(itemFamilyId);
+            }
+            itemFamilySet.add(itemFamilyId);
+          }else{
+            itemFamilySet.add(itemFamilyId);
+          }
+        }
+      }
+    }
+    return releasedForDevelopmentItemIds;
+  }
+
+  meetsCriteria(aItem): boolean {
+    const item = aItem['item'];
+    const lifecycleStage = item['lifecycleStage'];
+
+    return lifecycleStage && !this.config.itemPreDevelopmentLifecycleStages.includes(lifecycleStage);
+  }
+  async processPublish(pcd: PublishChangeData, changeDetail, fullChange, deleteChanges) {
+    console.info('processPublish-start');
+
+    const assortmentItemFullChangeMap = this.getFullChangeAssortmentMap(fullChange);
+    const assortmentItemDeleteMap = this.getDeleteChangesAssortmentMap(deleteChanges);
+    pcd.itemFamilyChanges = this.getItemFamilyChanges(pcd, changeDetail, assortmentItemFullChangeMap, assortmentItemDeleteMap);
+
+    const events = await this.getEventsForPublishChangeData(pcd);
+    if (events.length === 0) {
+      const message = 'No Events to Send; returning';
+      console.log(message);
+      return {
+        results: { message },
+        skip_await: true
+      };
+    }
+
+    const results = await this.sendEvents(events);
+    return { results };
+  }
+
+  private async sendEvents(events: SeasonalPayload[]): Promise<any> {
+    console.info('sendEvents()');
+    const eventType = 'ASYNC_PUBLISH_SEASON';
+    const sendMode = (this.config['sendMode'][eventType] || '').toLowerCase();
+
+    switch (sendMode) {
+    case 'sendtoflexplm':
+      return this.sendToFlexPLM(events, eventType);
+    case 'localfile':
+      return this.saveToLocalFile(events, eventType);
+    case 'vibeiqfile':
+    case 'vibeiqfile-dontsendtoflexplm':
+      return this.handleVibeIQFile(events, eventType, sendMode);
+    default:
+      return {}; // Or handle other cases as required
+    }
+  }
+
+  private async sendToFlexPLM(events: SeasonalPayload[], eventType: string) {
+    const asyncEvent: AsyncEventsPayloadType = {
+      taskId: this.config.taskId,
+      eventType,
+      objectClass: 'LCSSeason',
+      events
+    };
+
+    const flexPLMConnect = new FlexPLMConnect(this.config);
+    return await flexPLMConnect.sendToFlexPLM(asyncEvent);
+  }
+
+  private async saveToLocalFile(events: SeasonalPayload[], eventType: string) {
+    let results = {};
+    let fileHandle;
+
+    try {
+      const dateString = this.getCurrentDateString();
+      const dirName = await path.resolve();
+      await fsPromise.mkdir(dirName, { recursive: true });
+      const eventDirName = 'events-output';
+      const fileName = `${path.sep}${eventDirName}${path.sep}events-${dateString}.json`;
+      fileHandle = await fsPromise.open('.' + fileName, 'a');
+
+      const asyncEvent: AsyncEventsPayloadType = {
+        taskId: this.config.taskId,
+        eventType,
+        objectClass: 'LCSSeason',
+        events
+      };
+
+      await fileHandle.writeFile(JSON.stringify(asyncEvent));
+
+      results = {
+        message: 'Successfully Saved File',
+        fileLocation: dirName + fileName
+      };
+    } catch (e) {
+      results['error'] = e.message;
+    } finally {
+      await fileHandle?.close();
+    }
+
+    return results;
+  }
+
+  private async handleVibeIQFile(events: SeasonalPayload[], eventType: string, sendMode: string) {
+    const eventBuffer = Buffer.from(JSON.stringify(events), 'utf-8');
+    const fileName = 'ASYNC_PUBLISH_SEASON-events.json';
+    const uploadFile = await new Files().createAndUploadFileFromBuffer(eventBuffer, 'application/json', fileName, null, this.TTL);
+
+    const asyncEvent: AsyncEventsPayloadType = {
+      taskId: this.config.taskId,
+      eventType,
+      objectClass: 'LCSSeason',
+      eventsFileId: uploadFile.id,
+      eventsDownloadLink: uploadFile.downloadUrl
+    };
+
+    if (sendMode === 'vibeiqfile') {
+      const flexPLMConnect = new FlexPLMConnect(this.config);
+      return await flexPLMConnect.sendToFlexPLM(asyncEvent);
+    } else {
+      return {
+        message: 'Successfully Uploaded File.',
+        asyncEvent
+      };
+    }
+  }
+
+  private getCurrentDateString() {
+    const d = new Date();
+    return '' + d.getUTCFullYear()
+      + '-' + d.getUTCMonth()
+      + '-' + (d.getUTCDate() + 1)
+      + '-' + d.getUTCHours()
+      + '-' + d.getUTCMinutes()
+      + '-' + d.getUTCSeconds()
+      + '-' + d.getUTCMilliseconds();
+  }
+
+  getItemFamilyChanges(pcd: PublishChangeData, changeDetail, assortmentItemFullChangeMap: Map<string, any>, assortmentItemDeleteMap: Map<string, any>): Map<string, ItemFamilyChanges> {
+    console.info('getItemFamilyChanges-start');
+
+    const itemFamilyChanges = new Map<string, ItemFamilyChanges>();
+    const { adds, deletes, updates, familyItemsRemoved } = changeDetail;
+    const addIds = adds.map(item => item.id);
+    const deleteIds = deletes.map(item => item.id);
+    const updateIds = updates.map(item => item.id);
+    const familyItemsRemovedIds = familyItemsRemoved.map(item => item.itemId);
+
+    for (const [itemId, aItem] of assortmentItemFullChangeMap) {
+      const { item: { itemFamilyId }, projectItem } = aItem;
+
+      if (!pcd.releasedForDevelopmentItemIds.includes(itemFamilyId) || !pcd.releasedForDevelopmentItemIds.includes(itemId)) {
+        continue;
+      }
+
+      const ifc = itemFamilyChanges.get(itemFamilyId) || new ItemFamilyChanges(itemFamilyId, pcd.sinceDate);
+      if (!itemFamilyChanges.has(itemFamilyId)) {
+        ifc.itemFamilyObject = itemId === itemFamilyId ? aItem?.item : aItem?.item?.itemFamily;
+        itemFamilyChanges.set(itemFamilyId, ifc);
+      }
+
+      ifc.assortmentItemFullChangeMap.set(itemId, aItem);
+      if (pcd.itemToFederatedIdMapping.has(itemId)) {
+        ifc.itemToFederatedIdMapping.set(itemId, pcd.itemToFederatedIdMapping.get(itemId));
+      }
+
+      if (itemId === itemFamilyId) {
+        if (addIds.includes(itemId)) ifc.familyAdd = true;
+        else if (deleteIds.includes(itemId)) ifc.familyDelete = true;
+        else if (updateIds.includes(itemId)) ifc.familyUpdate = true;
+        else if (familyItemsRemovedIds.includes(itemId)) ifc.familyItemRemoved = true;
+
+        if (projectItem) {
+          const updatedOnDate = new Date(projectItem.updatedOn);
+          if (updatedOnDate > pcd.sinceDate) {
+            ifc.familyUpdate = true;
+          }
+        }
+
+        if (projectItem && !projectItem?.roles && aItem?.item?.roles) {
+          projectItem.roles = aItem?.item?.roles;
+        }
+
+      } else {
+        if (addIds.includes(itemId)) ifc.colorAdds.push(itemId);
+        else if (deleteIds.includes(itemId)) ifc.colorDeletes.push(itemId);
+        else if (updateIds.includes(itemId)) ifc.colorUpdates.push(itemId);
+        else if (projectItem && new Date(projectItem.updatedOn) > pcd.sinceDate) ifc.colorUpdates.push(itemId);
+        else ifc.colorUnchanged.push(itemId);
+
+        if (projectItem && !projectItem?.roles && aItem?.item?.roles) {
+          projectItem.roles = aItem?.item?.roles;
+        }
+      }
+    }
+
+    for(const [itemId, delEntity] of assortmentItemDeleteMap){
+      const itemFamilyId = delEntity['item']['itemFamilyId'];
+
+      const item = delEntity['item'];
+      if(!pcd.releasedForDevelopmentItemIds.includes(itemFamilyId) || !pcd.releasedForDevelopmentItemIds.includes(itemId)){
+        continue;
+      } else {
+        if(!item){
+          console.error('Failed to find deleted item entity');
+          console.error(' itemFamilyId: ' + itemFamilyId + ' -itemId: ' + itemId);
+          continue;
+        }
+
+      }
+
+      let ifc = itemFamilyChanges.get(itemFamilyId);
+      if(!ifc){
+        ifc = new ItemFamilyChanges(itemFamilyId, pcd.sinceDate);
+        if(itemId === itemFamilyId){
+          ifc.familyDelete = true;
+          ifc.itemFamilyObject = item;
+        } else{
+          ifc.itemFamilyObject = item?.itemFamily;
+        }
+        itemFamilyChanges.set(itemFamilyId, ifc);
+      }
+      if(pcd.itemToFederatedIdMapping.has(itemId)){
+        ifc.itemToFederatedIdMapping.set(itemId, pcd.itemToFederatedIdMapping.get(itemId));
+      }
+      ifc.assortmentItemDeleteMap.set(itemId, delEntity);
+      ifc.assortmentItemFullChangeMap.set(itemId, delEntity);
+
+      if(itemId === itemFamilyId){
+        ifc.familyDelete = true;
+      }else {
+        ifc.colorDeletes.push(itemId);
+      }
+    }//End deletes for loop
+    if(Logger.isDebugOn()){
+      console.debug('returning size: ' + itemFamilyChanges.size);
+      for (const [key, value] of itemFamilyChanges){
+        console.debug(key + ' => ' + value);
+      }
+    }
+
+
+    return itemFamilyChanges;
+  }
+
+  async getEventsForPublishChangeData(publishChangeData: PublishChangeData): Promise<SeasonalPayload[]> {
+    console.info('getEventsForPublishChangeData-start');
+    const seasonalPayloads: SeasonalPayload[] = [];
+    for (const itemFamilyChange of publishChangeData.itemFamilyChanges.values()) {
+      const events = await this.getEventsForItemFamilyChanges(itemFamilyChange, publishChangeData.assortmentId, publishChangeData.seasonFed, publishChangeData.itemToFederatedIdMapping);
+      if (events.length > 0) {
+        seasonalPayloads.push(...events);
+      }
+    }
+    return seasonalPayloads;
+  }
+
+  /**Returns the events for a given ItemFamilyChanges object
+   *
+   * Cases:
+   * Add just family:
+   * Add option to family (with existing option):
+   * Add option to family (no options on assortment):
+   * Remove family and option:
+   * Remove only option and leave family:
+   * Remove one option of multiple for family:
+   *
+   * @param itemFamilyChanges
+   * @param assortmentId
+   * @param assortmentFederationId
+   * @param itemToFederatedIdMapping
+   * @returns
+   */
+  async getEventsForItemFamilyChanges(itemFamilyChanges: ItemFamilyChanges, assortmentId: string, seasonFed: SeasonFederation, itemToFederatedIdMapping: Map<string, string>): Promise<SeasonalPayload[]> {
+    console.info('getEventsForItemFamilyChanges()');
+    const events: SeasonalPayload[] = [];
+    const LCSSeason = Object.assign({}, seasonFed);
+
+    const projectItem = this.getProjectItem(itemFamilyChanges, itemFamilyChanges.itemFamilyId);
+    const familyAssortmentItem = itemFamilyChanges.familyAdd || itemFamilyChanges.familyUpdate || itemFamilyChanges.familyDelete
+      || itemFamilyChanges.colorAdds.length > 0 || itemFamilyChanges.colorUpdates.length > 0 || itemFamilyChanges.colorDeletes.length > 0
+      || (projectItem && this.updatedSinceDate(projectItem, itemFamilyChanges.sinceDate));
+    //familyItemRemoved is used when adding the first option to an assortment
+    //and will have updates for the family item.
+
+    if (familyAssortmentItem) {
+      //Product-season add
+      const entityReference = itemFamilyChanges.itemFamilyId;
+      const prodEntityData = (itemFamilyChanges.assortmentItemFullChangeMap.has(entityReference))
+        ? itemFamilyChanges.assortmentItemFullChangeMap.get(entityReference)['item']
+        : itemFamilyChanges.itemFamilyObject;
+
+      let seasonalData = await this.getSeasonalData(projectItem);
+      seasonalData = await MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, seasonalData, 'LCSProductSeasonLink', 'vibe2flex');
+
+      const LCSProduct: ProductFederation = await this.getProductFederation(entityReference, itemToFederatedIdMapping, prodEntityData);
+      const psUpsert: SeasonalPayload = {
+        eventType: 'UPSERT_ON_SEASON',
+        objectClass: 'LCSProductSeasonLink',
+        entityReference: 'item:' + entityReference,
+        LCSSeason,
+        LCSProduct,
+        data: seasonalData
+      };
+
+      if('ASSORTMENT' === projectItem.addedFromSource && projectItem.addedFromAssortment){
+        const carriedFromSeason = await this.getCarriedFromSeason(projectItem);
+        if(carriedFromSeason){
+          psUpsert['carriedFromSeason'] = carriedFromSeason;
+        }
+      }
+
+      events.push(psUpsert);
+    }
+    //colorway-season adds
+    //colorAdds
+    //colorUpdates
+    const colorwayChanges = [];
+    colorwayChanges.push(...itemFamilyChanges.colorAdds);
+    colorwayChanges.push(...itemFamilyChanges.colorUpdates);
+    colorwayChanges.push(...itemFamilyChanges.colorDeletes);
+
+    for (const entityReference of colorwayChanges) {
+      let item = {};
+      if (itemFamilyChanges.assortmentItemFullChangeMap.has(entityReference)) {
+        const fullAi = itemFamilyChanges.assortmentItemFullChangeMap.get(entityReference);
+        item = fullAi['item'];
+      }
+      const projectItem = this.getProjectItem(itemFamilyChanges, entityReference);
+      let seasonalData = await this.getSeasonalData(projectItem);
+      seasonalData = await MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, seasonalData, 'LCSSKUSeasonLink', 'vibe2flex');
+
+      const LCSSKU: SkuFederation = await this.getSKUFederation(entityReference, itemToFederatedIdMapping, item);
+      const csUpsert: SeasonalPayload = {
+        eventType: 'UPSERT_ON_SEASON',
+        objectClass: 'LCSSKUSeasonLink',
+        entityReference: 'item:' + entityReference,
+        LCSSeason,
+        LCSSKU,
+        data: seasonalData
+
+      };
+
+      if('ASSORTMENT' === projectItem.addedFromSource && projectItem.addedFromAssortment){
+        const carriedFromSeason = await this.getCarriedFromSeason(projectItem);
+        if(carriedFromSeason){
+          csUpsert['carriedFromSeason'] = carriedFromSeason;
+        }
+      }
+
+      events.push(csUpsert);
+    }
+
+    return events;
+
+  }
+
+  getProjectItem(itemFamilyChanges: ItemFamilyChanges, id: string) {
+    let projectItem: any = {};
+    if (itemFamilyChanges?.assortmentItemFullChangeMap.has(id)) {
+      const aItem = itemFamilyChanges?.assortmentItemFullChangeMap.get(id);
+      projectItem = aItem?.projectItem;
+    }
+    /////////////////////////////////////////////////////////////////////////////
+    //Get from option assortmentItem because family not in assortmentItemFullChangeMap:start
+    /////////////////////////////////////////////////////////////////////////////
+    if (id === itemFamilyChanges.itemFamilyId && Object.keys(projectItem).length == 0) {
+      for (const asstItem of itemFamilyChanges.assortmentItemFullChangeMap.values()) {
+        if(asstItem?.familyProjectItem){
+          projectItem = asstItem?.familyProjectItem;
+          break;
+        }
+      }
+    }
+    /////////////////////////////////////////////////////////////////////////////
+    //Get from option assortmentItem because family not in assortmentItemFullChangeMap:end
+    /////////////////////////////////////////////////////////////////////////////
+    return projectItem;
+  }
+
+  async getSeasonalData(projectItem): Promise<object> {
+    return await this.dc.getFlexPLMObjectData(projectItem, [], true);
+  }
+
+  protected async getProductFederation(entityReference: string, itemToFederatedIdMapping: Map<string, string>, itemFamilyObject): Promise<ProductFederation> {
+    const identifierKeys: string[] = this.config?.identifierAtts?.LCSProduct;
+    const itemObj = await this.dc.getFlexPLMObjectData(itemFamilyObject, [], true);
+    let prodObj: ProductFederation = {
+      entityReference: 'item:' + entityReference,
+      objectClass: 'LCSProduct' as const,
+    };
+
+    for (const key of identifierKeys) {
+      if (itemObj[key]) {
+        prodObj[key] = itemObj[key];
+      }
+    }
+
+    if (!prodObj?.vibeIQIdentifier) {
+      prodObj.vibeIQIdentifier = itemFamilyObject?.identifier || itemFamilyObject?.itemNumber;
+    }
+
+    prodObj = await MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, prodObj, 'LCSProduct', 'vibe2flex');
+    return prodObj as ProductFederation;
+  }
+
+  protected async getSKUFederation(entityReference: string, itemToFederatedIdMapping: Map<string, string>, itemObject): Promise<SkuFederation> {
+    const identifierKeys: string[] = this.config?.identifierAtts?.LCSSKU;
+    const itemObj = await this.dc.getFlexPLMObjectData(itemObject, [], true);
+    let skuObj: SkuFederation = {
+      entityReference: 'item:' + entityReference,
+      objectClass: 'LCSSKU' as const,
+    };
+    for (const key of identifierKeys) {
+      if (itemObj[key]) {
+        skuObj[key] = itemObj[key];
+      }
+    }
+
+    if (!skuObj?.vibeIQIdentifier) {
+      skuObj.vibeIQIdentifier = itemObject?.identifier || itemObject?.itemNumber;
+    }
+
+    skuObj = await MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, skuObj, 'LCSSKU', 'vibe2flex');
+    return skuObj as SkuFederation;
+  }
+
+  async getCarriedFromSeason(projectItem): Promise<SeasonFederation> {
+    const addedFromAssortment = projectItem.addedFromAssortment;
+    if(this.cache.carriedFromSeason[addedFromAssortment]){
+      return this.cache.carriedFromSeason[addedFromAssortment];
+    }
+    let seasonFederation = undefined;
+    const assortmentEntity = await this.getAssormentEntityFromId(addedFromAssortment);
+    if(assortmentEntity){
+      seasonFederation = await this.getSeasonFederationFromAssortment(assortmentEntity);
+    }
+    this.cache.carriedFromSeason[addedFromAssortment] = seasonFederation;
+
+    return seasonFederation;
+  }
+
+  async getAssormentEntityFromId(assortmentId) {
+    let assortment;
+    try {
+      assortment = await new Entities().get({
+        entityName: 'assortment',
+        id: assortmentId
+      });
+    } catch (e) {
+      console.warn(`No Assortment found for id: ${assortmentId}`);
+    }
+    return assortment;
+  }
+
+  async getSeasonFederationFromAssortment(assortment): Promise<SeasonFederation>{
+
+    assortment['flex2vibeMapKeyRoot'] = 'LCSSeason';
+    const flexPLMTypePath = await TypeConversionUtils.getObjectTypePath(this.transformMapFile, this.mapFileUtil, assortment);
+
+    let seasonObj: any = {
+      entityReference: 'assortment:' + assortment.id,
+      objectClass: 'LCSSeason' as const,
+      flexPLMTypePath
+    };
+
+    try{
+      const assortmentObj = await this.dc.getFlexPLMObjectData(assortment, [], true);
+      const identifierKeys: string[] = await TypeConversionUtils.getIdentifierProperties(this.transformMapFile, this.mapFileUtil, assortment);
+      const informationKeys: string[] = await TypeConversionUtils.getInformationalProperties(this.transformMapFile, this.mapFileUtil, assortment);
+      for(const key of identifierKeys.concat(informationKeys)){
+        if(assortmentObj[key]){
+          seasonObj[key] = assortmentObj[key];
+        }
+      }
+      const objectKeys = Object.keys(seasonObj);
+      const hasAllIdentifiers = identifierKeys.every(key => objectKeys.includes(key));
+
+      if(!hasAllIdentifiers){
+        return undefined;
+      }
+
+      const mapKey:string  = await TypeConversionUtils.getMapKey(this.transformMapFile, this.mapFileUtil, assortment, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+      seasonObj = await MapUtil.applyTransformMap(this.transformMapFile, this.mapFileUtil, seasonObj, mapKey, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+    } finally {
+      delete assortment['flex2vibeMapKeyRoot'];
+    }
+
+    return seasonObj as SeasonFederation;
+
+  }
+
+}