feat: trim footprints to 2D coordinates (#30)

* feat: trim footprints to 2D coordinates

* chore: update fixpatchMetadataPayload

---------

Co-authored-by: Asaf Masa <>

Author: asafMasa

src/metadata/models/metadataManager.ts

@@ -10,6 +10,7 @@ import { AppError } from '../../common/appError';
 import { CatalogCall } from '../../externalServices/catalog/catalogCall';
 import { LogContext, UpdatePayload, UpdateStatusPayload } from '../../common/interfaces';
 import { Record3D } from '../../externalServices/catalog/interfaces';
+import { convertPolygonTo2DPolygon, convertStringToGeojson } from '../../model/models/utilities';
 
 @injectable()
 export class MetadataManager {
@@ -70,6 +71,10 @@ export class MetadataManager {
       throw new AppError('error', StatusCodes.INTERNAL_SERVER_ERROR, String(err), true);
     }
     try {
+      if (payload.footprint != undefined) {
+        const footprint3DOr2D = convertStringToGeojson(JSON.stringify(payload.footprint));
+        payload.footprint = convertPolygonTo2DPolygon(footprint3DOr2D);
+      }
       const response = await this.catalog.patchMetadata(identifier, payload);
       return response;
     } catch (err) {

src/model/models/modelManager.ts

@@ -13,7 +13,13 @@ import { FILE_ENCODING, SERVICES } from '../../common/constants';
 import { FailedReason, ValidationManager } from '../../validator/validationManager';
 import { AppError } from '../../common/appError';
 import { IConfig, IngestionPayload, IngestionValidatePayload, LogContext, ValidationResponse } from '../../common/interfaces';
-import { convertStringToGeojson, changeBasePathToPVPath, replaceBackQuotesWithQuotes, removePvPathFromModelPath } from './utilities';
+import {
+  convertStringToGeojson,
+  changeBasePathToPVPath,
+  replaceBackQuotesWithQuotes,
+  removePvPathFromModelPath,
+  convertPolygonTo2DPolygon,
+} from './utilities';
 
 export const ERROR_STORE_TRIGGER_ERROR: string = 'store-trigger service is not available';
 
@@ -141,8 +147,8 @@ export class ModelManager {
     spanActive?.setAttributes({
       [THREE_D_CONVENTIONS.three_d.catalogManager.catalogId]: modelId,
     });
-
     const adjustedModelPath = this.getAdjustedModelPath(payload.modelPath);
+    payload.metadata.footprint = convertPolygonTo2DPolygon(payload.metadata.footprint);
     const request: StoreTriggerPayload = {
       modelId: modelId,
       pathToTileset: removePvPathFromModelPath(adjustedModelPath),

src/model/models/utilities.ts

@@ -1,5 +1,5 @@
 import { sep, relative } from 'node:path';
-import { Polygon } from 'geojson';
+import { Polygon, Position } from 'geojson';
 import config from 'config';
 
 export const changeBasePathToPVPath = (modelPath: string): string => {
@@ -22,3 +22,11 @@ export const replaceBackQuotesWithQuotes = (path: string): string => {
 export const convertStringToGeojson = (geojson: string): Polygon => {
   return JSON.parse(geojson) as Polygon;
 };
+
+export const convertPolygonTo2DPolygon = (polygon: Polygon): Polygon => {
+  polygon.coordinates = polygon.coordinates.map((polygonInPolygon: Position[]) => {
+    /* eslint-disable-next-line @typescript-eslint/no-magic-numbers */
+    return polygonInPolygon.map((coordinate: Position) => coordinate.slice(0, 2));
+  });
+  return polygon;
+};

tests/helpers/3DModels/Sphere/footprint3D.json

@@ -0,0 +1,12 @@
+{
+  "type": "Polygon",
+  "coordinates": [
+    [
+      [35.2670012825, 32.5856881598, 5],
+      [35.2670012825, 32.6300363309, 9],
+      [35.3105702702, 32.6300363309, 9],
+      [35.3105702702, 32.5856881598, 9],
+      [35.2670012825, 32.5856881598, 5]
+    ]
+  ]
+}

tests/helpers/helpers.ts

@@ -99,8 +99,9 @@ export const createTilesetFileName = (): string => {
   return 'tileset.json';
 };
 
-export const createFootprint = (modelName = 'Sphere'): Polygon => {
-  const jsonString: string = readFileSync(`${pvPath}/${modelName}/footprint.json`, 'utf8');
+export const createFootprint = (modelName = 'Sphere', is3D = false): Polygon => {
+  const fileName = !is3D ? 'footprint' : 'footprint3D';
+  const jsonString: string = readFileSync(`${pvPath}/${modelName}/${fileName}.json`, 'utf8');
   return JSON.parse(jsonString) as Polygon;
 };
 

tests/integration/metadata/metadataController.spec.ts

@@ -12,12 +12,14 @@ import {
   createWrongFootprintSchema,
   createRecord,
   createWrongFootprintMixed2D3D,
+  createFootprint,
 } from '../../helpers/helpers';
 import { getApp } from '../../../src/app';
 import { SERVICES } from '../../../src/common/constants';
 import { S3Helper } from '../../helpers/s3Helper';
 import { S3Config } from '../../../src/common/interfaces';
 import { extractLink } from '../../../src/validator/extractPathFromLink';
+import { CatalogCall } from '../../../src/externalServices/catalog/catalogCall';
 import { MetadataRequestSender } from './helpers/requestSender';
 
 describe('MetadataController', function () {
@@ -66,6 +68,53 @@ describe('MetadataController', function () {
         expect(response.status).toBe(StatusCodes.OK);
         expect(response).toSatisfyApiSpec();
       });
+
+      it(`Should return 200 status code and metadata if payload is valid and footprint is 3D and pass footprint 2D to catalog`, async function () {
+        const identifier = faker.string.uuid();
+        const payload = createUpdatePayload('Sphere');
+        payload.footprint = createFootprint('Sphere', true);
+        const expectedFootprint = createFootprint('Sphere', false);
+        const expected = createRecord();
+        const record = createRecord();
+        const linkUrl = extractLink(record.links);
+        await s3Helper.createFile(linkUrl, true);
+        mockAxios.get.mockResolvedValueOnce({ status: StatusCodes.OK, data: record });
+        mockAxios.get.mockResolvedValueOnce({ data: [{ value: payload.classification }] as ILookupOption[] });
+        mockAxios.patch.mockResolvedValueOnce({ status: StatusCodes.OK, data: expected });
+
+        const catalogCallPatchPayloadSpy = jest.spyOn(CatalogCall.prototype, 'patchMetadata');
+        const patchMetadataPayload = {
+          productName: payload.productName,
+          sourceDateStart: payload.sourceDateStart?.toISOString(),
+          sourceDateEnd: payload.sourceDateEnd?.toISOString(),
+          footprint: expectedFootprint,
+          description: payload.description,
+          creationDate: payload.creationDate?.toISOString(),
+          minResolutionMeter: payload.minResolutionMeter,
+          maxResolutionMeter: payload.maxResolutionMeter,
+          maxAccuracyCE90: payload.maxAccuracyCE90,
+          absoluteAccuracyLE90: payload.absoluteAccuracyLE90,
+          accuracySE90: payload.accuracySE90,
+          relativeAccuracySE90: payload.relativeAccuracySE90,
+          visualAccuracy: payload.visualAccuracy,
+          heightRangeFrom: payload.heightRangeFrom,
+          heightRangeTo: payload.heightRangeTo,
+          classification: payload.classification,
+          producerName: payload.producerName,
+          maxFlightAlt: payload.maxFlightAlt,
+          minFlightAlt: payload.minFlightAlt,
+          geographicArea: payload.geographicArea,
+        };
+
+        const response = await requestSender.updateMetadata(identifier, payload);
+
+        /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+        expect(catalogCallPatchPayloadSpy).toHaveBeenCalledTimes(1);
+        expect(catalogCallPatchPayloadSpy).toHaveBeenCalledWith(expect.any(String), patchMetadataPayload);
+
+        expect(response.status).toBe(StatusCodes.OK);
+        expect(response).toSatisfyApiSpec();
+      });
     });
 
     describe('Bad Path 😡', function () {

tests/integration/model/modelController.spec.ts

@@ -20,6 +20,7 @@ import {
   getBasePath,
   getModelNameByPath,
   createWrongFootprintMixed2D3D,
+  createFootprint,
 } from '../../helpers/helpers';
 import { getApp } from '../../../src/app';
 import { SERVICES } from '../../../src/common/constants';
@@ -127,6 +128,75 @@ describe('ModelController', function () {
         expect(response.status).toBe(StatusCodes.CREATED);
         expect(response).toSatisfyApiSpec();
       });
+
+      it('should return 201 status code if footprint has 3D coordinates and pass footprint 2D to storeTrigger', async function () {
+        const payload = createIngestionPayload('Sphere');
+        payload.metadata.minResolutionMeter = 11;
+        payload.metadata.producerName = 'aa';
+        payload.metadata.footprint = createFootprint('Sphere', true);
+        const expectedFootprint = createFootprint('Sphere', false);
+
+        const storeTriggerResult: StoreTriggerResponse = {
+          jobId: faker.string.uuid(),
+          status: OperationStatus.IN_PROGRESS,
+        };
+        mockAxios.get.mockResolvedValueOnce({ status: StatusCodes.OK });
+        mockAxios.get.mockResolvedValueOnce({ data: [{ value: payload.metadata.classification }] as ILookupOption[] });
+        mockAxios.post.mockResolvedValueOnce({ data: storeTriggerResult });
+
+        const storeTriggerCallPostPayloadSpy = jest.spyOn(StoreTriggerCall.prototype, 'postPayload');
+
+        const response = await requestSender.createModel(payload);
+
+        expect(storeTriggerCallPostPayloadSpy).toHaveBeenCalledTimes(1);
+
+        const subsetPostPayloadMetadata = {
+          absoluteAccuracyLE90: payload.metadata.absoluteAccuracyLE90,
+          accuracySE90: payload.metadata.accuracySE90,
+          classification: payload.metadata.classification,
+          creationDate: payload.metadata.creationDate?.toISOString(),
+          description: payload.metadata.description,
+          footprint: expectedFootprint,
+          geographicArea: payload.metadata.geographicArea,
+          heightRangeFrom: payload.metadata.heightRangeFrom,
+          heightRangeTo: payload.metadata.heightRangeTo,
+          maxAccuracyCE90: payload.metadata.maxAccuracyCE90,
+          maxFlightAlt: payload.metadata.maxFlightAlt,
+          maxResolutionMeter: payload.metadata.maxResolutionMeter,
+          minFlightAlt: payload.metadata.minFlightAlt,
+          minResolutionMeter: payload.metadata.minResolutionMeter,
+          producerName: payload.metadata.producerName,
+          productId: payload.metadata.productId,
+          productName: payload.metadata.productName,
+          productSource: '\\\\tmp\\tilesets\\models\\Sphere',
+          productStatus: 'UNPUBLISHED',
+          productType: '3DPhotoRealistic',
+          productionSystem: payload.metadata.productionSystem,
+          productionSystemVer: payload.metadata.productionSystemVer,
+          region: payload.metadata.region,
+          relativeAccuracySE90: payload.metadata.relativeAccuracySE90,
+          sensors: payload.metadata.sensors,
+          sourceDateEnd: `${payload.metadata.sourceDateEnd?.toISOString()}`,
+          sourceDateStart: `${payload.metadata.sourceDateStart?.toISOString()}`,
+          srsId: payload.metadata.srsId,
+          srsName: payload.metadata.srsName,
+          type: 'RECORD_3D',
+          visualAccuracy: payload.metadata.visualAccuracy,
+        };
+
+        /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+        expect(storeTriggerCallPostPayloadSpy).toHaveBeenCalledWith(
+          expect.objectContaining({
+            modelId: expect.any(String),
+            pathToTileset: 'Sphere',
+            tilesetFilename: 'tileset.json',
+            metadata: subsetPostPayloadMetadata,
+          })
+        );
+
+        expect(response.status).toBe(StatusCodes.CREATED);
+        expect(response).toSatisfyApiSpec();
+      });
     });
 
     describe('Sad Path 😥, createModel', function () {

tests/unit/model/models/utilities.spec.ts

@@ -5,7 +5,9 @@ import {
   changeBasePathToPVPath,
   removePvPathFromModelPath,
   replaceBackQuotesWithQuotes,
+  convertPolygonTo2DPolygon,
 } from '../../../../src/model/models/utilities';
+import { createFootprint } from '../../../helpers/helpers';
 
 describe('utilities tests', () => {
   describe('removeFootprintSpaces tests', () => {
@@ -19,6 +21,16 @@ describe('utilities tests', () => {
     });
   });
 
+  describe('convertPolygonTo2DPolygon tests', () => {
+    it('Should return footprint 2D from 3D', () => {
+      const footprint3D = createFootprint('Sphere', true);
+      const expectedFootprint2D = createFootprint('Sphere', false);
+
+      const result = convertPolygonTo2DPolygon(footprint3D);
+      expect(result).toStrictEqual(expectedFootprint2D);
+    });
+  });
+
   describe('changeBasePathToPVPath tests', () => {
     it('Should return mounted path', () => {
       const basePath: string = config.get<string>('paths.basePath') + '\\model\\path';