Cost Surface - shapefile converting & extracting PU cost/id

api/apps/api/src/decorators/shapefile.decorator.ts

@@ -1,3 +1,4 @@
+import { isDefined } from '@marxan/utils';
 import { applyDecorators } from '@nestjs/common';
 import {
   ApiBody,
@@ -7,7 +8,6 @@ import {
 } from '@nestjs/swagger';
 
 import { ShapefileGeoJSONResponseDTO } from '@marxan-api/modules/scenarios/dto/shapefile.geojson.response.dto';
-import { isDefined } from '../utils/is-defined';
 
 export function ApiConsumesShapefile(withGeoJsonResponse = true) {
   return applyDecorators(

api/apps/api/src/modules/analysis/providers/shared/adapters/are-puids-allowed-adapter.ts

@@ -1,9 +1,9 @@
 import { Injectable } from '@nestjs/common';
+import { isDefined } from '@marxan/utils';
 import { differenceWith } from 'lodash';
 import { ArePuidsAllowedPort } from '../are-puids-allowed.port';
 
 import { ScenariosPlanningUnitService } from '../../../../scenarios-planning-unit/scenarios-planning-unit.service';
-import { isDefined } from '../../../../../utils/is-defined';
 
 @Injectable()
 export class ArePuidsAllowedAdapter

api/apps/api/test/jest-e2e.json

@@ -8,6 +8,8 @@
     "^.+\\.(t|j)s$": "ts-jest"
   },
   "moduleNameMapper": {
-    "@marxan-api/(.*)": "<rootDir>/../src/$1"
+    "@marxan-api/(.*)": "<rootDir>/../src/$1",
+    "^@marxan/utils": ["<rootDir>/../../../libs/utils/src"],
+    "^@marxan/utils/(.*)$": ["<rootDir>/../../..//libs/utils/src/$1"]
   }
 }

api/apps/geoprocessing/src/modules/surface-cost/adapters/pu-cost-extractor.spec.ts

@@ -0,0 +1,62 @@
+import { Test } from '@nestjs/testing';
+import { PromiseType } from 'utility-types';
+import {
+  getGeoJson,
+  getGeoJsonWithMissingCost,
+  getGeometryMultiPolygon,
+} from '../application/__mocks__/geojson';
+import { PuCostExtractor } from './pu-cost-extractor';
+
+let sut: PuCostExtractor;
+let fixtures: PromiseType<ReturnType<typeof getFixtures>>;
+
+beforeEach(async () => {
+  fixtures = await getFixtures();
+  sut = fixtures.getService();
+});
+
+describe(`when features miss cost`, () => {
+  it(`throws exception`, () => {
+    expect(() => sut.extract(fixtures.geoFeaturesWithoutCost())).toThrow(
+      /missing cost/,
+    );
+  });
+});
+
+describe(`when given GeoJson isn't a FeatureCollection`, () => {
+  it(`throws exception`, () => {
+    expect(() => sut.extract(fixtures.simpleGeometry())).toThrow(
+      /Only FeatureCollection is supported/,
+    );
+  });
+});
+
+describe(`when given GeoJson has pu costs`, () => {
+  it(`resolves them`, () => {
+    expect(sut.extract(fixtures.geoFeaturesWithData())).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "cost": 200,
+          "planningUnitId": "uuid-1",
+        },
+        Object {
+          "cost": 100,
+          "planningUnitId": "uuid-2",
+        },
+      ]
+    `);
+  });
+});
+
+const getFixtures = async () => {
+  const sandbox = await Test.createTestingModule({
+    providers: [PuCostExtractor],
+  }).compile();
+
+  return {
+    getService: () => sandbox.get(PuCostExtractor),
+    geoFeaturesWithoutCost: () => getGeoJsonWithMissingCost(),
+    geoFeaturesWithData: () => getGeoJson(),
+    simpleGeometry: () => getGeometryMultiPolygon(),
+  };
+};

api/apps/geoprocessing/src/modules/surface-cost/adapters/pu-cost-extractor.ts

@@ -0,0 +1,48 @@
+import { isDefined } from '@marxan/utils';
+import { MaybeProperties } from '@marxan/utils/types';
+import { FeatureCollection, GeoJSON, Geometry } from 'geojson';
+import { PlanningUnitCost } from '../ports/planning-unit-cost';
+import { PuExtractorPort } from '../ports/pu-extractor/pu-extractor.port';
+
+type Properties = {
+  cost: number;
+  planningUnitId: string;
+};
+
+type MaybeCost = MaybeProperties<Properties>;
+
+export class PuCostExtractor implements PuExtractorPort {
+  extract(geo: GeoJSON): PlanningUnitCost[] {
+    if (!this.isFeatureCollection(geo)) {
+      throw new Error('Only FeatureCollection is supported.');
+    }
+    const input: FeatureCollection<Geometry, MaybeCost> = geo;
+
+    const puCosts = input.features
+      .map((feature) => feature.properties)
+      .filter(this.hasCostValues);
+
+    if (puCosts.length !== input.features.length) {
+      throw new Error(
+        `Some of the Features are missing cost and/or planning unit id.`,
+      );
+    }
+
+    return puCosts.map((puCost) => ({
+      planningUnitId: puCost.planningUnitId,
+      cost: puCost.cost,
+    }));
+  }
+
+  private isFeatureCollection(geo: GeoJSON): geo is FeatureCollection {
+    return geo.type === 'FeatureCollection';
+  }
+
+  private hasCostValues(properties: MaybeCost): properties is Properties {
+    return (
+      isDefined(properties) &&
+      isDefined(properties.cost) &&
+      isDefined(properties.planningUnitId)
+    );
+  }
+}

api/apps/geoprocessing/src/modules/surface-cost/adapters/shapefile-converter.ts

@@ -0,0 +1,13 @@
+import { GeoJSON } from 'geojson';
+import { ShapefileService } from '../../shapefiles/shapefiles.service';
+
+import { CostSurfaceJobInput } from '../cost-surface-job-input';
+import { ShapefileConverterPort } from '../ports/shapefile-converter/shapefile-converter.port';
+
+export class ShapefileConverter implements ShapefileConverterPort {
+  constructor(private readonly converter: ShapefileService) {}
+
+  async convert(file: CostSurfaceJobInput['shapefile']): Promise<GeoJSON> {
+    return (await this.converter.getGeoJson(file)).data;
+  }
+}

api/apps/geoprocessing/src/modules/surface-cost/application/__mocks__/geojson.ts

@@ -1,4 +1,4 @@
-import { Feature, FeatureCollection, MultiPolygon, Polygon } from 'geojson';
+import { FeatureCollection, MultiPolygon, Polygon } from 'geojson';
 import { PlanningUnitCost } from '../../ports/planning-unit-cost';
 
 export const getGeoJson = (): FeatureCollection<
@@ -56,3 +56,8 @@ export const getGeoJsonWithMissingCost = (): FeatureCollection<
     },
   ],
 });
+
+export const getGeometryMultiPolygon = (): MultiPolygon => ({
+  type: 'MultiPolygon',
+  coordinates: [],
+});

api/apps/geoprocessing/src/modules/surface-cost/surface-cost.module.ts

@@ -1,6 +1,7 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { WorkerModule, WorkerProcessor } from '../worker';
+import { ShapefilesModule } from '../shapefiles/shapefiles.module';
 
 import { SurfaceCostProcessor } from './application/surface-cost-processor';
 import { SurfaceCostWorker } from './application/surface-cost-worker';
@@ -11,12 +12,15 @@ import { ArePuidsAllowedPort } from './ports/pu-validator/are-puuids-allowed.por
 import { ShapefileConverterPort } from './ports/shapefile-converter/shapefile-converter.port';
 
 import { TypeormCostSurface } from './adapters/typeorm-cost-surface';
+import { ShapefileConverter } from './adapters/shapefile-converter';
 import { ScenariosPuCostDataGeo } from '../scenarios/scenarios-pu-cost-data.geo.entity';
 import { ScenariosPlanningUnitGeoEntity } from '../scenarios/scenarios-planning-unit.geo.entity';
+import { PuCostExtractor } from './adapters/pu-cost-extractor';
 
 @Module({
   imports: [
     WorkerModule,
+    ShapefilesModule,
     TypeOrmModule.forFeature([
       ScenariosPuCostDataGeo,
       ScenariosPlanningUnitGeoEntity, // not used but has to imported somewhere
@@ -38,11 +42,11 @@ import { ScenariosPlanningUnitGeoEntity } from '../scenarios/scenarios-planning-
     },
     {
       provide: PuExtractorPort,
-      useValue: {},
+      useClass: PuCostExtractor,
     },
     {
       provide: ShapefileConverterPort,
-      useValue: {},
+      useClass: ShapefileConverter,
     },
   ],
 })

api/apps/geoprocessing/test/jest-e2e.json

@@ -9,6 +9,8 @@
     "^.+\\.(t|j)s$": "ts-jest"
   },
   "moduleNameMapper": {
-    "@marxan-geoprocessing/(.*)": "<rootDir>/src/$1"
+    "@marxan-geoprocessing/(.*)": "<rootDir>/src/$1",
+    "^@marxan/utils": ["<rootDir>/../../libs/utils/src"],
+    "^@marxan/utils/(.*)$": ["<rootDir>/../..//libs/utils/src/$1"]
   }
 }

api/libs/utils/src/index.ts

@@ -0,0 +1 @@
+export { isDefined } from './is-defined';

api/libs/utils/src/types/index.ts

@@ -0,0 +1 @@
+export { MaybeProperties } from './maybe-properties';

api/libs/utils/src/types/maybe-properties.ts

@@ -0,0 +1 @@
+export type MaybeProperties<T> = Partial<T> | undefined | null;

api/libs/utils/tsconfig.lib.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "../../dist/libs/utils"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test", "**/*spec.ts"]
+}

api/nest-cli.json

@@ -25,6 +25,15 @@
       "compilerOptions": {
         "tsConfigPath": "apps/geoprocessing/tsconfig.app.json"
       }
+    },
+    "utils": {
+      "type": "library",
+      "root": "libs/utils",
+      "entryFile": "index",
+      "sourceRoot": "libs/utils/src",
+      "compilerOptions": {
+        "tsConfigPath": "libs/utils/tsconfig.lib.json"
+      }
     }
   }
-}
+}

api/package.json

@@ -79,7 +79,6 @@
     "unzipper": "^0.10.11",
     "uuid": "8.3.2",
     "swagger-ui-express": "^4.1.6"
-
   },
   "devDependencies": {
     "@nestjs/cli": "^7.5.1",
@@ -145,7 +144,9 @@
     ],
     "moduleNameMapper": {
       "@marxan-api/(.*)": "<rootDir>/apps/api/src/$1",
-      "@marxan-geoprocessing/(.*)": "<rootDir>/apps/geoprocessing/src/$1"
+      "@marxan-geoprocessing/(.*)": "<rootDir>/apps/geoprocessing/src/$1",
+      "@marxan/utils/(.*)": "<rootDir>/libs/utils/src/$1",
+      "@marxan/utils": "<rootDir>/libs/utils/src"
     }
   }
 }

api/tsconfig.json

@@ -18,11 +18,17 @@
       ],
       "@marxan-api/*": [
         "apps/api/src/*"
+      ],
+      "@marxan/utils": [
+        "libs/utils/src"
+      ],
+      "@marxan/utils/*": [
+        "libs/utils/src/*"
       ]
     }
   },
   "exclude": [
     "node_modules",
     "dist"
   ]
-}
+}