@contrail/flexplm 1.2.1 → 1.3.0-alpha.04c91a9

package/src/util/thumbnail-util.ts

@@ -1,8 +1,15 @@
 import { Logger } from '@contrail/app-framework';
-import { Entities } from '@contrail/sdk';
+import { Content, Entities } from '@contrail/sdk';
 import { FCConfig } from '../interfaces/interfaces';
+import { FlexPLMConnect } from './flexplm-connect';
 
+interface ContentCustomSize {
+  id: string;
+  slug: string;
+  name: string;
+};
 export class ThumbnailUtil {
+  /** The max_thumbnail_size is for limiting the size of the thumbnail being sent to FlexPLM.  It is used when checking the size of the auto generated thumbnails (smallViewable, tinyViewable, etc.). */
   private max_thumbnail_size = 5 * 1_024 * 1_024;
   private entities: Entities;
   static NEW_THUMBNAIL_ID = 'NEW_THUMBNAIL_ID';
@@ -54,7 +61,7 @@ export class ThumbnailUtil {
       return false;
     }
 
-  public async getFileId(primaryViewableId: string): Promise<string> {
+  public async getFileId(primaryViewableId: string): Promise<string | undefined> {
     console.info('ThumbnailUtil.getFileId()-' + primaryViewableId);
     const sizes = await this.getCustomSizes();
 
@@ -95,16 +102,16 @@ export class ThumbnailUtil {
     return fileId;
   }
 
-  async getCustomSizes() {
+  async getCustomSizes(): Promise<ContentCustomSize[]> {
     const customSizes = await this.entities.get({
       entityName: 'content-custom-size'
     });
-    const sizes = [];
+    const sizes: ContentCustomSize[] = [];
     sizes.push(...customSizes);
     return sizes;
   }
 
-  async getContentEntity(primaryViewableId: any, sizes: any[]) {
+  async getContentEntity(primaryViewableId: any, sizes: ContentCustomSize[]) {
     const relations = sizes.map(s => s.slug);
     relations.push('primaryFile');
     const content = await this.entities.get({
@@ -134,4 +141,132 @@ export class ThumbnailUtil {
       }
     }
 
+  /** Syncs the thumbnail from FlexPLM to VibeIQ. Handles creating, replacing, or removing
+   * the primary viewable content and persists the updates directly to the entity.
+   *
+   * @param entityId - The ID of the entity to update with thumbnail properties.
+   * @param primaryViewableId - The existing primary viewable content ID, if any.
+   * @param event - The inbound event containing thumbnail data (NEW_THUMBNAIL_ID / EXISTING_THUMBNAIL_ID).
+   * @param entityName - The entity type name (e.g. 'item', 'color') used for API calls.
+   * @returns The updated entity, or undefined if no thumbnail changes were needed.
+   */
+  async syncThumbnailToVibeIQ({ entityId, primaryViewableId, event, entityName }: { entityId: string; primaryViewableId?: string; event: any; entityName: string }): Promise<any> {
+    console.debug(`syncThumbnailToVibeIQ: entityId=${entityId}, primaryViewableId=${primaryViewableId}, entityName=${entityName}`);
+    const eventData = event.data || {};
+    const newThumbnailId = eventData[ThumbnailUtil.NEW_THUMBNAIL_ID];
+    const existingThumbnailId = eventData[ThumbnailUtil.EXISTING_THUMBNAIL_ID];
+    const thumbnailUrl = newThumbnailId || existingThumbnailId;
+
+    // Case 1: REMOVE_THUMBNAIL
+    if (newThumbnailId === ThumbnailUtil.REMOVE_THUMBNAIL) {
+      if (primaryViewableId) {
+        await this.entities.delete({ entityName: 'content', id: primaryViewableId });
+      }
+      const clearUpdates = await this.getClearPrimaryViewableUpdates();
+      const updatedEntity = await this.entities.update({ entityName, id: entityId, object: clearUpdates });
+      console.debug(`syncThumbnailToVibeIQ: applied clear updates for entityId=${entityId}`);
+      return updatedEntity;
+    }
+
+    // Early return if no thumbnail URL
+    if (!thumbnailUrl) {
+      console.debug(`syncThumbnailToVibeIQ: no thumbnail URL for entityId=${entityId}`);
+      return undefined;
+    }
+
+    // Case 2: No existing primaryViewableId — create new content
+    if (!primaryViewableId) {
+      const content = await this.createContentFromFlexPLM(thumbnailUrl, entityId, entityName);
+      await this.entities.update({ entityName: 'content', id: content.id, object: { flexplmThumbnailUrl: thumbnailUrl } });
+      const primaryUpdates = await this.getPrimaryViewableUpdates(content);
+      const updatedEntity = await this.entities.update({ entityName, id: entityId, object: primaryUpdates });
+      console.debug(`syncThumbnailToVibeIQ: created new content ${content.id} for entityId=${entityId}`);
+      return updatedEntity;
+    }
+
+    // Case 3: Has primaryViewableId — check if thumbnail changed
+    const primaryViewable = await this.entities.get({ entityName: 'content', id: primaryViewableId });
+    if (primaryViewable?.flexplmThumbnailUrl === thumbnailUrl) {
+      console.debug(`syncThumbnailToVibeIQ: thumbnail already synced for entityId=${entityId}`);
+      return undefined; // Already synced
+    }
+
+    const content = await this.createContentFromFlexPLM(thumbnailUrl, entityId, entityName);
+    await this.entities.update({ entityName: 'content', id: content.id, object: { flexplmThumbnailUrl: thumbnailUrl } });
+    const primaryUpdates = await this.getPrimaryViewableUpdates(content);
+    const updatedEntity = await this.entities.update({ entityName, id: entityId, object: primaryUpdates });
+    await this.entities.delete({ entityName: 'content', id: primaryViewableId });
+    console.debug(`syncThumbnailToVibeIQ: replaced content ${primaryViewableId} with ${content.id} for entityId=${entityId}`);
+    return updatedEntity;
+  }
+
+  private async createContentFromFlexPLM(thumbnailUrl: string, entityId: string, entityName: string): Promise<any> {
+    const urlParts = thumbnailUrl.split('/');
+    const fileName = urlParts[urlParts.length - 1] || 'thumbnail';
+
+    const encodedUrl = urlParts.map(part => encodeURIComponent(part)).join('/');
+    const flexPLMConnect = new FlexPLMConnect(this.config);
+    const response = await flexPLMConnect.getRequest({
+      urlPath: encodedUrl,
+      includeUrlContext: false,
+      returnFullResponse: true,
+    }) as Response;
+
+    const fileBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(fileBuffer);
+    const contentTypeHeader = response.headers.get('content-type');
+    const contentType = contentTypeHeader ? contentTypeHeader.split(';')[0] : 'application/octet-stream';
+
+    const contentHolderReference = `${entityName}:${entityId}`;
+    const content = await new Content().create({
+      fileBuffer: buffer,
+      fileName,
+      contentType,
+      contentHolderReference,
+    });
+    return content;
+  }
+
+  private async getPrimaryViewableUpdates(content: any): Promise<any> {
+    const updates: any = {
+      primaryViewableId: content.id,
+      contentType: content.contentType,
+      fileName: content.fileName,
+      primaryFileUrl: content.primaryFileUrl,
+      largeViewableDownloadUrl: content.largeViewableUrl || content.primaryFileUrl,
+      mediumLargeViewableDownloadUrl: content.mediumLargeViewableUrl || content.primaryFileUrl,
+      mediumViewableDownloadUrl: content.mediumViewableUrl || content.primaryFileUrl,
+      smallViewableDownloadUrl: content.smallViewableUrl || content.primaryFileUrl,
+      tinyViewableDownloadUrl: content.tinyViewableUrl || content.primaryFileUrl,
+    };
+
+    const customSizes = await this.getCustomSizes();
+    for (const size of customSizes) {
+      updates[`${size.slug}DownloadUrl`] = content[`${size.slug}Url`] || content.primaryFileUrl;
+    }
+
+    return updates;
+  }
+
+  private async getClearPrimaryViewableUpdates(): Promise<any> {
+    const updates: any = {
+      primaryViewableId: null,
+      contentType: null,
+      fileName: null,
+      primaryFileUrl: null,
+      largeViewableDownloadUrl: null,
+      mediumLargeViewableDownloadUrl: null,
+      mediumViewableDownloadUrl: null,
+      smallViewableDownloadUrl: null,
+      tinyViewableDownloadUrl: null,
+    };
+
+    const customSizes = await this.getCustomSizes();
+    for (const size of customSizes) {
+      updates[`${size.slug}DownloadUrl`] = null;
+    }
+
+    return updates;
+  }
+
 }

package/src/util/type-conversion-utils-spec-mockData.ts

@@ -142,6 +142,12 @@ exports.mapping = {
     isOutboundCreatable: (entity, context) => {
       return false;
     },
+    syncInboundImages: (entity, context) => {
+      return true;
+    },
+    syncOutboundImages: (entity, context) => {
+      return false;
+    },
     vibe2flex: {
       transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
       rekey: {
@@ -175,6 +181,18 @@ exports.mapping = {
       }
       return true;
     },
+    syncInboundImages: (entity, context) => {
+      if (context && context.skipImages) {
+        return false;
+      }
+      return true;
+    },
+    syncOutboundImages: (entity, context) => {
+      if (context && context.skipImages) {
+        return false;
+      }
+      return true;
+    },
     vibe2flex: {
       transformOrder: [{ processor: 'REKEY', rekeyDelete: true, rekeyTransformersKey: 'rekey' }],
       rekey: {

package/src/util/type-conversion-utils.spec.ts

@@ -781,4 +781,188 @@ describe('conversion-utils', () => {
     });
 
   });
+
+  describe('syncInboundImages', () =>{
+    const mapFileUtil = new MapFileUtil(new Entities());
+
+    it('should return true for Revisable Entity\\packaging (mapping entry true)', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const obj = {
+        flexPLMObjectClass: 'LCSRevisableEntity',
+        flexPLMTypePath: 'Revisable Entity\\packaging'
+      }
+
+      try{
+        const results = await TypeConversionUtils.syncInboundImages(TRANSFORM_MAP_FILE, mapFileUtil, obj);
+        expect(results).toBeTruthy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should return true for Revisable Entity\\prefix (mapping entry true)', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const obj = {
+        flexPLMObjectClass: 'LCSRevisableEntity',
+        flexPLMTypePath: 'Revisable Entity\\prefix'
+      }
+
+      try{
+        const results = await TypeConversionUtils.syncInboundImages(TRANSFORM_MAP_FILE, mapFileUtil, obj);
+        expect(results).toBeTruthy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should pass context to syncInboundImages function', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const obj = {
+        flexPLMObjectClass: 'LCSRevisableEntity',
+        flexPLMTypePath: 'Revisable Entity\\prefix'
+      }
+      const context = { skipImages: true };
+
+      try{
+        const results = await TypeConversionUtils.syncInboundImages(TRANSFORM_MAP_FILE, mapFileUtil, obj, context);
+        expect(results).toBeFalsy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should default to false when no mapping exists', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const obj = {
+        flexPLMObjectClass: 'LCSRevisableEntity',
+        flexPLMTypePath: 'Revisable Entity\\catName'
+      }
+
+      try{
+        const results = await TypeConversionUtils.syncInboundImages(TRANSFORM_MAP_FILE, mapFileUtil, obj);
+        expect(results).toBeFalsy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should default to false when no fileId', async () =>{
+      const obj = {
+        flexPLMObjectClass: 'LCSRevisableEntity',
+        flexPLMTypePath: 'Revisable Entity\\pack'
+      }
+
+      const results = await TypeConversionUtils.syncInboundImages('', mapFileUtil, obj);
+      expect(results).toBeFalsy();
+    });
+
+  });
+
+  describe('syncOutboundImages', () =>{
+    const mapFileUtil = new MapFileUtil(new Entities());
+
+    it('should return false for custom-entity:pack (mapping entry false)', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:pack'
+      }
+
+      try{
+        const results = await TypeConversionUtils.syncOutboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+        expect(results).toBeFalsy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should return true for custom-entity:prefix (mapping entry true)', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:prefix'
+      }
+
+      try{
+        const results = await TypeConversionUtils.syncOutboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+        expect(results).toBeTruthy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should pass context to syncOutboundImages function', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:prefix'
+      }
+      const context = { skipImages: true };
+
+      try{
+        const results = await TypeConversionUtils.syncOutboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity, context);
+        expect(results).toBeFalsy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should default to true when no mapping exists', async () =>{
+      const spy = jest.spyOn(mapFileUtil, 'getMapFile')
+        .mockImplementation(async () =>{
+          return mapping;
+        });
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:catName'
+      }
+
+      try{
+        const results = await TypeConversionUtils.syncOutboundImages(TRANSFORM_MAP_FILE, mapFileUtil, entity);
+        expect(results).toBeTruthy();
+
+      } finally {
+        spy.mockRestore();
+      }
+    });
+
+    it('should default to true when no fileId', async () =>{
+      const entity = {
+        entityType: 'custom-entity',
+        typePath: 'custom-entity:pack'
+      }
+
+      const results = await TypeConversionUtils.syncOutboundImages('', mapFileUtil, entity);
+      expect(results).toBeTruthy();
+    });
+
+  });
 });

package/src/util/type-conversion-utils.ts

@@ -323,7 +323,7 @@ export class TypeConversionUtils {
     return TypeDefaults.getDefaultInformationalPropertiesFromObject(object);
   }
 
-  static async getMapKeyFromObject(fileId, mapFileUtil: MapFileUtil, object: any, direction:string): Promise<string> {
+  static async getMapKeyFromObject(fileId, mapFileUtil: MapFileUtil, object: any, direction:string): Promise<string | undefined> {
     const type = this.getObjectType(object);
     if(fileId){
       const mappingData = await mapFileUtil.getMappingSection(fileId, 'typeConversion', direction);
@@ -377,6 +377,80 @@ export class TypeConversionUtils {
     return isOutboundCreatable;
   }
 
+  /** Takes in a FlexPLM object and determines whether inbound
+   * images should be synced. In most cases, the creation owning system
+   * will also control image syncing. Defaults to false if no mapping exists.
+   * Map file entry in '<mapKey>:syncInboundImages()'
+   *
+   * @param fileId id for mapFile
+   * @param mapFileUtil class to get mapfile
+   * @param object FlexPLM object
+   * @param context optional context object
+   * @returns Promise<boolean>
+   */
+  static async syncInboundImages(fileId: string, mapFileUtil: MapFileUtil, object: any, context?: any): Promise<boolean> {
+
+    let syncImages = false;
+
+    if (!fileId) {
+      return syncImages;
+    }
+
+    let mapKey: string | undefined;
+    try {
+      mapKey = await this.getMapKeyFromObject(fileId, mapFileUtil, object, TypeConversionUtils.FLEX2VIBE_DIRECTION);
+    } catch {
+      return syncImages;
+    }
+
+    if (!mapKey) {
+      return syncImages;
+    }
+
+    const mapData = await MapUtil.getFullMapSection(fileId, mapFileUtil, mapKey);
+    if (mapData && mapData['syncInboundImages']) {
+      syncImages = await mapData['syncInboundImages'](object, context);
+    }
+    return syncImages;
+  }
+
+  /** Takes in a VibeIQ entity object and determines whether outbound
+   * images should be synced. In most cases, the creation owning system
+   * will also control image syncing. Defaults to true if no mapping exists.
+   * Map file entry in '<mapKey>:syncOutboundImages()'
+   *
+   * @param fileId id for mapFile
+   * @param mapFileUtil class to get mapfile
+   * @param entity VibeIQ entity
+   * @param context optional context object
+   * @returns Promise<boolean>
+   */
+  static async syncOutboundImages(fileId: string, mapFileUtil: MapFileUtil, entity: any, context?: any): Promise<boolean> {
+
+    let syncImages = true;
+
+    if (!fileId) {
+      return syncImages;
+    }
+
+    let mapKey: string | undefined;
+    try {
+      mapKey = await this.getMapKey(fileId, mapFileUtil, entity, TypeConversionUtils.VIBE2FLEX_DIRECTION);
+    } catch {
+      return syncImages;
+    }
+
+    if (!mapKey) {
+      return syncImages;
+    }
+
+    const mapData = await MapUtil.getFullMapSection(fileId, mapFileUtil, mapKey);
+    if (mapData && mapData['syncOutboundImages']) {
+      syncImages = await mapData['syncOutboundImages'](entity, context);
+    }
+    return syncImages;
+  }
+
   static getObjectType(object:any) {
     let objectType = object['flexPLMObjectClass'];
     return objectType;