@contrail/flexplm 1.2.1 → 1.3.0-alpha.3

package/src/util/thumbnail-util.spec.ts

@@ -3,6 +3,33 @@ import { ThumbnailUtil } from './thumbnail-util';
 
 import { empty_custom_sizes, four_custom_sizes, thumbnail_content_entity } from './mockData';
 
+const mockEntitiesGet = jest.fn();
+const mockEntitiesUpdate = jest.fn();
+const mockEntitiesDelete = jest.fn();
+const mockContentCreate = jest.fn();
+
+jest.mock('@contrail/sdk', () => {
+  return {
+    Entities: jest.fn().mockImplementation(() => ({
+      get: mockEntitiesGet,
+      update: mockEntitiesUpdate,
+      delete: mockEntitiesDelete,
+    })),
+    Content: jest.fn().mockImplementation(() => ({
+      create: mockContentCreate,
+    })),
+  };
+});
+
+const mockGetRequest = jest.fn();
+jest.mock('./flexplm-connect', () => {
+  return {
+    FlexPLMConnect: jest.fn().mockImplementation(() => ({
+      getRequest: mockGetRequest,
+    })),
+  };
+});
+
 describe('ThumbnailUtil Tests', () =>{
   const config = {} as FCConfig;
   describe('setOutboundThumbnail()', () =>{
@@ -266,4 +293,167 @@ describe('ThumbnailUtil Tests', () =>{
     });
 
   });
+
+  describe('syncThumbnailToVibeIQ', () => {
+    let tu: ThumbnailUtil;
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+      tu = new ThumbnailUtil(config);
+      mockEntitiesGet.mockImplementation((opts) => {
+        if (opts.entityName === 'content-custom-size') return Promise.resolve([]);
+        return Promise.resolve({});
+      });
+      mockEntitiesUpdate.mockImplementation((opts) => Promise.resolve({ id: opts.id }));
+      mockEntitiesDelete.mockImplementation((opts) => Promise.resolve({ id: opts.id }));
+    });
+
+    it('returns undefined when no thumbnail IDs in event data', async () => {
+      const event = { data: {} };
+      const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'color' });
+
+      expect(result).toBeUndefined();
+      expect(mockEntitiesUpdate).not.toHaveBeenCalled();
+      expect(mockEntitiesDelete).not.toHaveBeenCalled();
+      expect(mockContentCreate).not.toHaveBeenCalled();
+    });
+
+    it('returns undefined when event.data is undefined', async () => {
+      const event = {};
+      const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'color' });
+
+      expect(result).toBeUndefined();
+      expect(mockEntitiesUpdate).not.toHaveBeenCalled();
+      expect(mockEntitiesDelete).not.toHaveBeenCalled();
+    });
+
+    it('REMOVE_THUMBNAIL with existing primaryViewableId deletes content and returns clear updates', async () => {
+      const event = { data: { [ThumbnailUtil.NEW_THUMBNAIL_ID]: ThumbnailUtil.REMOVE_THUMBNAIL } };
+      const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', primaryViewableId: 'pv1', event, entityName: 'color' });
+
+      expect(mockEntitiesDelete).toHaveBeenCalledWith({ entityName: 'content', id: 'pv1' });
+      expect(result).toEqual(expect.objectContaining({ primaryViewableId: null, primaryFileUrl: null }));
+    });
+
+    it('REMOVE_THUMBNAIL with no primaryViewableId returns clear updates without deleting', async () => {
+      const event = { data: { [ThumbnailUtil.NEW_THUMBNAIL_ID]: ThumbnailUtil.REMOVE_THUMBNAIL } };
+      const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'item' });
+
+      expect(mockEntitiesDelete).not.toHaveBeenCalled();
+      expect(result).toEqual(expect.objectContaining({ primaryViewableId: null }));
+    });
+
+    it('creates new content when no primaryViewableId exists and returns primary viewable updates', async () => {
+      const mockResponse = {
+        arrayBuffer: jest.fn().mockResolvedValue(new ArrayBuffer(8)),
+        headers: { get: jest.fn().mockReturnValue('image/png') },
+      };
+      mockGetRequest.mockResolvedValue(mockResponse);
+
+      const createdContent = {
+        id: 'newContent1',
+        contentType: 'image/png',
+        fileName: 'thumb.png',
+        primaryFileUrl: 'https://files/primary.png',
+        largeViewableUrl: 'https://files/large.png',
+        mediumLargeViewableUrl: null,
+        mediumViewableUrl: null,
+        smallViewableUrl: null,
+        tinyViewableUrl: null,
+      };
+      mockContentCreate.mockResolvedValue(createdContent);
+
+      const event = { data: { [ThumbnailUtil.NEW_THUMBNAIL_ID]: '/rest/thumbnail/thumb.png' } };
+      const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', event, entityName: 'color' });
+
+      expect(mockGetRequest).toHaveBeenCalledWith({ urlPath: '/rest/thumbnail/thumb.png', includeUrlContext: false, returnFullResponse: true });
+      expect(mockContentCreate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          fileName: 'thumb.png',
+          contentType: 'image/png',
+          contentHolderReference: 'color:entity1',
+        }),
+      );
+      // Updates content with flexplmThumbnailUrl
+      expect(mockEntitiesUpdate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          entityName: 'content',
+          id: 'newContent1',
+          object: { flexplmThumbnailUrl: '/rest/thumbnail/thumb.png' },
+        }),
+      );
+      // Returns primary viewable updates for the entity
+      expect(result).toEqual(expect.objectContaining({
+        primaryViewableId: 'newContent1',
+        primaryFileUrl: 'https://files/primary.png',
+        largeViewableDownloadUrl: 'https://files/large.png',
+      }));
+    });
+
+    it('replaces content when primaryViewable.flexplmThumbnailUrl differs and returns updates', async () => {
+      mockEntitiesGet.mockImplementation((opts) => {
+        if (opts.entityName === 'content-custom-size') return Promise.resolve([]);
+        if (opts.entityName === 'content' && opts.id === 'oldPv') {
+          return Promise.resolve({ id: 'oldPv', flexplmThumbnailUrl: '/rest/thumbnail/old.png' });
+        }
+        return Promise.resolve({});
+      });
+
+      const mockResponse = {
+        arrayBuffer: jest.fn().mockResolvedValue(new ArrayBuffer(8)),
+        headers: { get: jest.fn().mockReturnValue('image/jpeg') },
+      };
+      mockGetRequest.mockResolvedValue(mockResponse);
+
+      const createdContent = {
+        id: 'newContent2',
+        contentType: 'image/jpeg',
+        fileName: 'new.jpg',
+        primaryFileUrl: 'https://files/new-primary.jpg',
+        largeViewableUrl: null,
+        mediumLargeViewableUrl: null,
+        mediumViewableUrl: null,
+        smallViewableUrl: null,
+        tinyViewableUrl: null,
+      };
+      mockContentCreate.mockResolvedValue(createdContent);
+
+      const event = { data: { [ThumbnailUtil.NEW_THUMBNAIL_ID]: '/rest/thumbnail/new.jpg' } };
+      const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', primaryViewableId: 'oldPv', event, entityName: 'item' });
+
+      // Creates new content
+      expect(mockContentCreate).toHaveBeenCalled();
+      // Updates new content with flexplmThumbnailUrl
+      expect(mockEntitiesUpdate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          entityName: 'content',
+          id: 'newContent2',
+          object: { flexplmThumbnailUrl: '/rest/thumbnail/new.jpg' },
+        }),
+      );
+      // Returns primary viewable updates for the entity
+      expect(result).toEqual(expect.objectContaining({ primaryViewableId: 'newContent2' }));
+      // Deletes old content
+      expect(mockEntitiesDelete).toHaveBeenCalledWith({ entityName: 'content', id: 'oldPv' });
+    });
+
+    it('returns undefined when primaryViewable.flexplmThumbnailUrl matches', async () => {
+      const thumbnailUrl = '/rest/thumbnail/same.png';
+      mockEntitiesGet.mockImplementation((opts) => {
+        if (opts.entityName === 'content-custom-size') return Promise.resolve([]);
+        if (opts.entityName === 'content' && opts.id === 'pv1') {
+          return Promise.resolve({ id: 'pv1', flexplmThumbnailUrl: thumbnailUrl });
+        }
+        return Promise.resolve({});
+      });
+
+      const event = { data: { [ThumbnailUtil.EXISTING_THUMBNAIL_ID]: thumbnailUrl } };
+      const result = await tu.syncThumbnailToVibeIQ({ entityId: 'entity1', primaryViewableId: 'pv1', event, entityName: 'color' });
+
+      expect(result).toBeUndefined();
+      expect(mockContentCreate).not.toHaveBeenCalled();
+      expect(mockEntitiesUpdate).not.toHaveBeenCalled();
+      expect(mockEntitiesDelete).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/util/thumbnail-util.ts

@@ -1,6 +1,7 @@
 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';
 
 export class ThumbnailUtil {
   private max_thumbnail_size = 5 * 1_024 * 1_024;
@@ -134,4 +135,111 @@ export class ThumbnailUtil {
       }
     }
 
+  async syncThumbnailToVibeIQ({ entityId, primaryViewableId, event, entityName }: { entityId: string; primaryViewableId?: string; event: any; entityName: string }): Promise<any> {
+    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 });
+      }
+      return await this.getClearPrimaryViewableUpdates();
+    }
+
+    // Early return if no thumbnail URL
+    if (!thumbnailUrl) {
+      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 } });
+      return await this.getPrimaryViewableUpdates(content);
+    }
+
+    // Case 3: Has primaryViewableId — check if thumbnail changed
+    const primaryViewable = await this.entities.get({ entityName: 'content', id: primaryViewableId });
+    if (primaryViewable?.flexplmThumbnailUrl === thumbnailUrl) {
+      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);
+    await this.entities.delete({ entityName: 'content', id: primaryViewableId });
+    return primaryUpdates;
+  }
+
+  private async createContentFromFlexPLM(thumbnailUrl: string, entityId: string, entityName: string): Promise<any> {
+    const flexPLMConnect = new FlexPLMConnect(this.config);
+    const response = await flexPLMConnect.getRequest({
+      urlPath: thumbnailUrl,
+      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 urlParts = thumbnailUrl.split('/');
+    const fileName = urlParts[urlParts.length - 1] || 'thumbnail';
+
+    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

@@ -334,6 +334,7 @@ export class TypeConversionUtils {
       return type;
     }
     //TODO use TypeDefaults?
+    return '';
   }
 
   static async isInboundCreatableFromObject(fileId: string, mapFileUtil: MapFileUtil, object: any, context?: any): Promise<boolean> {
@@ -377,6 +378,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;