@contrail/flexplm 1.1.58 → 1.1.60

package/lib/entity-processor/base-entity-processor.d.ts

@@ -20,6 +20,7 @@ export declare abstract class BaseEntityProcessor {
     handleIncomingUpsert(event: EntityPayloadType): Promise<any>;
     getInboundStatusMessage(statusObject: any): string;
     queryEntityWithSubTypeCriteria(entityType: string, entityTypePath: string, propertyCriteria: any): Promise<any[]>;
+    getCriteriaForEntity(entityType: string, entityTypePath: string, propertyCriteria: any): Promise<any>;
     getRootTypePropertyKeys(rootType: any, propertyCriteria?: any): string[];
     handleIncomingDelete(event: any): Promise<void>;
     getTransformedData(event: any): Promise<any>;

package/lib/entity-processor/base-entity-processor.js

@@ -115,6 +115,17 @@ class BaseEntityProcessor {
             + ', orgSlug: ' + this.orgSlug;
     }
     async queryEntityWithSubTypeCriteria(entityType, entityTypePath, propertyCriteria) {
+        if (!entityType || !entityTypePath) {
+            throw new Error('type and entityTypePath must be defined');
+        }
+        if (!propertyCriteria || Object.getOwnPropertyNames(propertyCriteria).length == 0) {
+            throw new Error('propertyCriteria must be defined and have at least one property');
+        }
+        const { rootTypeCriteria, subTypeCriteria } = await this.getCriteriaForEntity(entityType, entityTypePath, propertyCriteria);
+        const returnedEntities = await this.dc.getAllObjectReferences(entityType, rootTypeCriteria, subTypeCriteria);
+        return returnedEntities;
+    }
+    async getCriteriaForEntity(entityType, entityTypePath, propertyCriteria) {
         if (!entityType || !entityTypePath) {
             throw new Error('type and entityTypePath must be defined');
         }
@@ -123,8 +134,11 @@ class BaseEntityProcessor {
         }
         const rootType = await this.typeUtil.getByRootAndPath({ root: entityType });
         const rootTypePropertyKeys = await this.getRootTypePropertyKeys(rootType, propertyCriteria);
-        const rootTypeCriteria = { typePath: entityTypePath };
+        const rootTypeCriteria = {};
         const subTypeCriteria = {};
+        if (entityType !== entityTypePath) {
+            subTypeCriteria['typePath'] = entityTypePath;
+        }
         for (const key in propertyCriteria) {
             if (rootTypePropertyKeys.includes(key)) {
                 rootTypeCriteria[key] = propertyCriteria[key];
@@ -133,8 +147,7 @@ class BaseEntityProcessor {
                 subTypeCriteria[key] = propertyCriteria[key];
             }
         }
-        const returnedEntities = await this.dc.getAllObjectReferences(entityType, rootTypeCriteria, subTypeCriteria);
-        return returnedEntities;
+        return { rootTypeCriteria, subTypeCriteria };
     }
     getRootTypePropertyKeys(rootType, propertyCriteria = null) {
         const props = rootType['typeProperties'];

package/lib/entity-processor/base-entity-processor.spec.js

@@ -96,6 +96,7 @@ describe('BaseEntityProcessor', () => {
         const config = {};
         const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
         beforeEach(() => {
+            jest.clearAllMocks();
         });
         it('entity parameter not set', async () => {
             const btep = new TestBaseEntityProcessor({}, {}, {}, 'test');
@@ -127,10 +128,11 @@ describe('BaseEntityProcessor', () => {
                 rootText: 'root'
             };
             const subCriteria = {
-                sampleText: 'sample'
+                sampleText: 'sample',
+                typePath: entityTypePath
             };
             const propertyCriteria = Object.assign({}, rootCriteria, subCriteria);
-            const rootCriteriaResults = Object.assign({ typePath: entityTypePath }, rootCriteria);
+            const rootCriteriaResults = Object.assign({}, rootCriteria);
             const mockGetByRootTypeProperties = jest.spyOn(btep, 'getRootTypePropertyKeys').mockReturnValue(['rootText']);
             const mockDCgetAllObjectReferences = jest.spyOn(dc, 'getAllObjectReferences').mockReturnValue(Promise.resolve([]));
             const results = await btep.queryEntityWithSubTypeCriteria(entityType, entityTypePath, propertyCriteria);
@@ -143,6 +145,58 @@ describe('BaseEntityProcessor', () => {
             expect(mockDCgetAllObjectReferences).toBeCalledWith(entityType, rootCriteriaResults, subCriteria);
         });
     });
+    describe('getCriteriaForEntity', () => {
+        const config = {};
+        const mapFileUtil = new transform_data_1.MapFileUtil(new sdk_1.Entities());
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('entity parameter not set', async () => {
+            const btep = new TestBaseEntityProcessor({}, {}, {}, 'test');
+            const entity = '';
+            const subType = 'test';
+            const propertyCriteria = { a: 'val' };
+            expect(async () => { await btep.getCriteriaForEntity(entity, subType, propertyCriteria); }).rejects.toThrow();
+        });
+        it('entityTypePath not set', async () => {
+            const btep = new TestBaseEntityProcessor({}, {}, {}, 'test');
+            const entity = 'test';
+            const subType = '';
+            const propertyCriteria = {};
+            expect(async () => { await btep.getCriteriaForEntity(entity, subType, propertyCriteria); }).rejects.toThrow();
+        });
+        it('propertyCriteria not set', async () => {
+            const btep = new TestBaseEntityProcessor({}, {}, {}, 'test');
+            const entity = 'test';
+            const subType = 'test';
+            const propertyCriteria = {};
+            expect(async () => { await btep.getCriteriaForEntity(entity, subType, propertyCriteria); }).rejects.toThrow();
+        });
+        it('basic getCriteriaForEntity test', async () => {
+            const dc = new data_converter_1.DataConverter(config, mapFileUtil);
+            const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
+            const entityType = 'custom-entity';
+            const entityTypePath = 'custom-entity:sample';
+            const rootCriteria = {
+                rootText: 'root'
+            };
+            const subCriteria = {
+                sampleText: 'sample',
+                typePath: entityTypePath
+            };
+            const propertyCriteria = Object.assign({}, rootCriteria, subCriteria);
+            const rootCriteriaResults = Object.assign({}, rootCriteria);
+            const subCriteriaResults = Object.assign({}, subCriteria);
+            const mockGetByRootTypeProperties = jest.spyOn(btep, 'getRootTypePropertyKeys').mockReturnValue(['rootText']);
+            const { rootTypeCriteria, subTypeCriteria } = await btep.getCriteriaForEntity(entityType, entityTypePath, propertyCriteria);
+            expect(mockTypeUtilGetByRootAndPath).toBeCalledTimes(1);
+            expect(mockTypeUtilGetByRootAndPath).toBeCalledWith({ root: entityType });
+            expect(mockGetByRootTypeProperties).toBeCalledTimes(1);
+            expect(mockGetByRootTypeProperties).toBeCalledWith(mockRootType, propertyCriteria);
+            expect(rootTypeCriteria).toEqual(rootCriteriaResults);
+            expect(subTypeCriteria).toEqual(subCriteriaResults);
+        });
+    });
     describe('getRootTypePropertyKeys', () => {
         it('rootType parameter not set', async () => {
             const btep = new TestBaseEntityProcessor({}, {}, {}, 'test');

package/lib/util/data-converter.js

@@ -416,7 +416,7 @@ class DataConverter {
             if (Object.keys(loadPage).includes('results')) {
                 usedV2 = true;
                 let postProcessedResults = loadPage.results;
-                if (postProcessCriteria && Object.keys(postProcessCriteria).length !== 0) {
+                if (postProcessedResults?.length > 0 && postProcessCriteria && Object.keys(postProcessCriteria).length !== 0) {
                     const subEntityTypePath = rootTypeCriteria.typePath || entityType;
                     postProcessedResults = this.checkKeysAndValues(postProcessCriteria, postProcessedResults, subEntityTypePath);
                 }

package/lib/util/data-converter.spec.js

@@ -287,7 +287,7 @@ describe('getPersistableChanges', () => {
         };
         const diffs = dc.getPersistableChanges(entity, potentialChanges);
         expect(Object.getOwnPropertyNames(diffs).length).toEqual(1);
-        expect(diffs['str']).toEqual(potentialChanges['str']);
+        expect(diffs['str']).toBeNull();
     });
 });
 describe('getObjectReferenceValue cache', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/flexplm",
-  "version": "1.1.58",
+  "version": "1.1.60",
   "description": "Library used for integration with flexplm.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -40,9 +40,10 @@
     "testEnvironment": "node"
   },
   "dependencies": {
-    "@contrail/app-framework": "^1.2.4",
-    "@contrail/sdk": "^1.3.7",
-    "@contrail/transform-data": "^1.1.1",
+    "@contrail/app-framework": "^1.3.4",
+    "@contrail/sdk": "^1.4.3",
+    "@contrail/transform-data": "^1.1.3",
+    "@contrail/util": "^1.0.48",
     "axios": "^1.4.0",
     "p-limit": "^3.1.0"
   }

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

@@ -104,7 +104,7 @@ describe('BaseEntityProcessor', () =>{
     const config = {} as FCConfig;
     const mapFileUtil = new MapFileUtil(new Entities());
     beforeEach(() =>{
-      // jest.clearAllMocks();
+      jest.clearAllMocks();
     });
     it('entity parameter not set', async () =>{
       const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');
@@ -138,10 +138,11 @@ describe('BaseEntityProcessor', () =>{
         rootText: 'root'
       };
       const subCriteria = {
-        sampleText: 'sample'
+        sampleText: 'sample',
+        typePath: entityTypePath
       };
       const propertyCriteria = Object.assign({}, rootCriteria, subCriteria);
-      const rootCriteriaResults = Object.assign({typePath: entityTypePath}, rootCriteria);
+      const rootCriteriaResults = Object.assign({}, rootCriteria);
 
       const mockGetByRootTypeProperties = jest.spyOn(btep, 'getRootTypePropertyKeys').mockReturnValue(['rootText']);
       const mockDCgetAllObjectReferences = jest.spyOn(dc, 'getAllObjectReferences').mockReturnValue(Promise.resolve([]));
@@ -159,6 +160,65 @@ describe('BaseEntityProcessor', () =>{
 
   });
 
+  describe('getCriteriaForEntity', () =>{
+    const config = {} as FCConfig;
+    const mapFileUtil = new MapFileUtil(new Entities());
+    beforeEach(() =>{
+      jest.clearAllMocks();
+    });
+    it('entity parameter not set', async () =>{
+      const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');
+      const entity = '';
+      const subType = 'test';
+      const propertyCriteria = {a:'val'};
+      expect(async () => {await btep.getCriteriaForEntity(entity, subType, propertyCriteria)}).rejects.toThrow();
+    });
+    it('entityTypePath not set', async () =>{
+      const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');
+      const entity = 'test';
+      const subType = '';
+      const propertyCriteria = {};
+      expect(async () => {await btep.getCriteriaForEntity(entity, subType, propertyCriteria)}).rejects.toThrow();
+
+    });
+    it('propertyCriteria not set', async () =>{
+      const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');
+      const entity = 'test';
+      const subType = 'test';
+      const propertyCriteria = {};
+      expect(async () => {await btep.getCriteriaForEntity(entity, subType, propertyCriteria)}).rejects.toThrow();
+    });
+
+    it('basic getCriteriaForEntity test', async () =>{
+      const dc = new DataConverter(config, mapFileUtil);
+      const btep = new TestBaseEntityProcessor(config, dc, mapFileUtil, 'test');
+      const entityType = 'custom-entity';
+      const entityTypePath = 'custom-entity:sample';
+      const rootCriteria = {
+        rootText: 'root'
+      };
+      const subCriteria = {
+        sampleText: 'sample',
+        typePath: entityTypePath
+      };
+      const propertyCriteria = Object.assign({}, rootCriteria, subCriteria);
+      const rootCriteriaResults = Object.assign({}, rootCriteria);
+      const subCriteriaResults = Object.assign({}, subCriteria);
+
+      const mockGetByRootTypeProperties = jest.spyOn(btep, 'getRootTypePropertyKeys').mockReturnValue(['rootText']);
+      // const mockDCgetAllObjectReferences = jest.spyOn(dc, 'getAllObjectReferences').mockReturnValue(Promise.resolve([]));
+
+      const {rootTypeCriteria, subTypeCriteria} = await btep.getCriteriaForEntity(entityType, entityTypePath, propertyCriteria);
+      expect(mockTypeUtilGetByRootAndPath).toBeCalledTimes(1);
+      expect(mockTypeUtilGetByRootAndPath).toBeCalledWith({ root: entityType});
+      expect(mockGetByRootTypeProperties).toBeCalledTimes(1);
+      expect(mockGetByRootTypeProperties).toBeCalledWith(mockRootType, propertyCriteria);
+      expect(rootTypeCriteria).toEqual(rootCriteriaResults);
+      expect(subTypeCriteria).toEqual(subCriteriaResults);
+
+    });
+  });
+
   describe('getRootTypePropertyKeys', () =>{
     it('rootType parameter not set', async () =>{
       const btep = new TestBaseEntityProcessor({} as FCConfig, {} as DataConverter, {} as MapFileUtil, 'test');

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

@@ -153,11 +153,37 @@ export abstract class BaseEntityProcessor {
       throw new Error('propertyCriteria must be defined and have at least one property');
     }
 
+    const {rootTypeCriteria, subTypeCriteria} = await this.getCriteriaForEntity(entityType, entityTypePath, propertyCriteria);
+
+    const returnedEntities = await this.dc.getAllObjectReferences(entityType, rootTypeCriteria, subTypeCriteria);
+
+    return returnedEntities;
+  }
+
+  /** This is to get the criteria for the entity that is being processed.
+   * This is to be overridden for item & project-item because of the need for
+   * setting the roles criteria.
+   *
+   * @param entityType: the root type of the entity
+   * @param entityTypePath: the full type path of the entity. Ex: custom-entity:sample
+   * @param propertyCriteria: all the criteria to search for the entity
+   * @returns the criteria for the entity
+   */
+  async getCriteriaForEntity(entityType: string, entityTypePath: string, propertyCriteria: any): Promise<any>{
+    if(!entityType || !entityTypePath){
+      throw new Error('type and entityTypePath must be defined');
+    }
+    if(!propertyCriteria || Object.getOwnPropertyNames(propertyCriteria).length == 0){
+      throw new Error('propertyCriteria must be defined and have at least one property');
+    }
     const rootType = await this.typeUtil.getByRootAndPath({root: entityType});
     const rootTypePropertyKeys = await this.getRootTypePropertyKeys(rootType, propertyCriteria);
 
-    const rootTypeCriteria = {typePath:entityTypePath};
+    const rootTypeCriteria = {};
     const subTypeCriteria = {};
+    if(entityType !== entityTypePath){
+      subTypeCriteria['typePath'] = entityTypePath;
+    }
     for(const key in propertyCriteria){
       if(rootTypePropertyKeys.includes(key)){
         rootTypeCriteria[key] = propertyCriteria[key];
@@ -166,9 +192,7 @@ export abstract class BaseEntityProcessor {
       }
     }
 
-    const returnedEntities = await this.dc.getAllObjectReferences(entityType, rootTypeCriteria, subTypeCriteria);
-
-    return returnedEntities;
+    return {rootTypeCriteria, subTypeCriteria};
   }
 
   /** This is to get the properties that are owned by the root type

package/src/util/data-converter.spec.ts

@@ -321,7 +321,7 @@ describe('getPersistableChanges', () =>{
 
     const diffs = dc.getPersistableChanges(entity, potentialChanges);
     expect(Object.getOwnPropertyNames(diffs).length).toEqual(1);
-    expect(diffs['str']).toEqual(potentialChanges['str']);
+    expect(diffs['str']).toBeNull();
   });
 
 });

package/src/util/data-converter.ts

@@ -513,7 +513,7 @@ export class DataConverter {
       if (Object.keys(loadPage).includes('results')) {
         usedV2 = true;
         let postProcessedResults = loadPage.results;
-        if(postProcessCriteria && Object.keys(postProcessCriteria).length !== 0) {
+        if(postProcessedResults?.length > 0 && postProcessCriteria && Object.keys(postProcessCriteria).length !== 0) {
           const subEntityTypePath = rootTypeCriteria.typePath || entityType;
           postProcessedResults = this.checkKeysAndValues(postProcessCriteria, postProcessedResults, subEntityTypePath);
         }