[MARXAN-353] [MARXAN-482] [MARXAN-483] geo features: POST and PUT interface

api/apps/api/src/migrations/api/1618241224000-AddDraftStatusToJobStatusEnum.ts

@@ -1,29 +1,20 @@
 import { MigrationInterface, QueryRunner } from 'typeorm';
 
-export class AllowToLinkCustomGeoFeaturesToProjects1618248224000
+export class AddDraftStatusToJobStatusEnum1618241224000
   implements MigrationInterface {
   public async up(queryRunner: QueryRunner): Promise<void> {
     await queryRunner.query(`
-ALTER TABLE features
-  ADD COLUMN project_id uuid references projects(id);
-ALTER TABLE features
-  ALTER COLUMN created_by DROP NOT NULL,
-  ALTER COLUMN created_at DROP NOT NULL,
-  ALTER COLUMN last_modified_at DROP NOT NULL;
+ALTER TYPE job_status ADD VALUE 'draft';
     `);
   }
 
-  public async down(queryRunner: QueryRunner): Promise<void> {
-    await queryRunner.query(`
-ALTER TABLE features
-  DROP COLUMN project_id;
-ALTER TABLE features
-  -- not adding back NOT NULL to the created_by column as we wouldn't know
-  -- which user(s) to set this to, at least until we implement full event
-  -- logging for create/update/delete, and even then it may be overkill to
-  -- use the event log to populate this field in the down side of a migration
-  ALTER COLUMN created_at SET NOT NULL,
-  ALTER COLUMN last_modified_at SET NOT NULL;
-    `);
+  public async down(_queryRunner: QueryRunner): Promise<void> {
+    /**
+     * Not dropping here the enum value that we add on the up side of the
+     * migration. In practice, this will involve just too many steps (altering
+     * references in all the columns that use this type before to switch over
+     * to a new type without the 'draft' status) for it to be useful at this
+     * stage of development.
+     */
   }
 }

api/apps/api/src/migrations/api/1618248224000-AllowToLinkCustomGeoFeaturesToProjects.ts

@@ -1,20 +1,29 @@
 import { MigrationInterface, QueryRunner } from 'typeorm';
 
-export class AddDraftStatusToJobStatusEnum1618241224000
+export class AllowToLinkCustomGeoFeaturesToProjects1618248224000
   implements MigrationInterface {
   public async up(queryRunner: QueryRunner): Promise<void> {
     await queryRunner.query(`
-ALTER TYPE job_status ADD VALUE 'draft';
+ALTER TABLE features
+  ADD COLUMN project_id uuid references projects(id);
+ALTER TABLE features
+  ALTER COLUMN created_by DROP NOT NULL,
+  ALTER COLUMN created_at DROP NOT NULL,
+  ALTER COLUMN last_modified_at DROP NOT NULL;
     `);
   }
 
-  public async down(_queryRunner: QueryRunner): Promise<void> {
-    /**
-     * Not dropping here the enum value that we add on the up side of the
-     * migration. In practice, this will involve just too many steps (altering
-     * references in all the columns that use this type before to switch over
-     * to a new type without the 'draft' status) for it to be useful at this
-     * stage of development.
-     */
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+ALTER TABLE features
+  DROP COLUMN project_id;
+ALTER TABLE features
+  -- not adding back NOT NULL to the created_by column as we wouldn't know
+  -- which user(s) to set this to, at least until we implement full event
+  -- logging for create/update/delete, and even then it may be overkill to
+  -- use the event log to populate this field in the down side of a migration
+  ALTER COLUMN created_at SET NOT NULL,
+  ALTER COLUMN last_modified_at SET NOT NULL;
+    `);
   }
 }

api/apps/api/src/migrations/api/1620040322000-GeoFeatureSets.ts

@@ -0,0 +1,17 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class GeoFeatureSets1620040322000 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+ALTER TABLE scenarios
+  ADD COLUMN feature_set jsonb;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+ALTER TABLE scenarios
+  DROP COLUMN feature_set;
+    `);
+  }
+}

api/apps/api/src/modules/geo-features/dto/create.geo-feature-set.dto.ts

@@ -0,0 +1,3 @@
+import { GeoFeatureSetSpecification } from './geo-feature-set-specification.dto';
+
+export class CreateGeoFeatureSetDTO extends GeoFeatureSetSpecification {}

api/apps/api/src/modules/geo-features/dto/geo-feature-set-specification.dto.ts

@@ -0,0 +1,88 @@
+import { SimpleJobStatus } from '@marxan-api/modules/scenarios/scenario.api.entity';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsEnum, IsUUID, ValidateNested } from 'class-validator';
+import { GeoFeature } from '../geo-feature.api.entity';
+import {
+  GeoprocessingOp,
+  GeoprocessingOpSplitV1,
+  GeoprocessingOpStratificationV1,
+} from '../types/geo-feature.geoprocessing-operations.type';
+import { MarxanSettingsForGeoFeature } from '../types/geo-feature.marxan-settings.type';
+
+export abstract class SpecForGeofeature {
+  @IsUUID()
+  @ApiProperty()
+  featureId!: string;
+
+  @IsEnum(['plain', 'withGeoprocessing'])
+  @ApiProperty()
+  kind!: 'plain' | 'withGeoprocessing';
+}
+
+export class SpecForPlainGeoFeature extends SpecForGeofeature {
+  @ValidateNested()
+  @Type(() => MarxanSettingsForGeoFeature)
+  @ApiProperty()
+  marxanSettings!: MarxanSettingsForGeoFeature;
+
+  geoprocessingOperations?: never;
+}
+
+export class SpecForPlainGeoFeatureWithFeatureMetadata extends SpecForPlainGeoFeature {
+  @ApiProperty()
+  metadata!: GeoFeature;
+}
+
+export class SpecForGeoFeatureWithGeoprocessing extends SpecForGeofeature {
+  @IsUUID()
+  @ApiProperty()
+  featureId!: string;
+
+  @ValidateNested({ each: true })
+  @Type(() => GeoprocessingOp, {
+    keepDiscriminatorProperty: true,
+    discriminator: {
+      property: 'kind',
+      subTypes: [
+        { value: GeoprocessingOpSplitV1, name: 'split/v1' },
+        { value: GeoprocessingOpStratificationV1, name: 'stratification/v1' },
+      ],
+    },
+  })
+  @ApiPropertyOptional()
+  geoprocessingOperations?: Array<
+    GeoprocessingOpSplitV1 | GeoprocessingOpStratificationV1
+  >;
+
+  marxanSettings?: never;
+}
+
+export class SpecForGeoFeatureWithGeoprocessingWithFeatureMetadata extends SpecForPlainGeoFeature {
+  @ApiProperty()
+  metadata!: GeoFeature;
+}
+
+export class GeoFeatureSetSpecification {
+  @ApiProperty()
+  // @IsEnum(Object.keys(SimpleJobStatus))
+  @IsEnum(['draft', 'created'])
+  status!: SimpleJobStatus;
+
+  @ApiProperty()
+  @ValidateNested({ each: true })
+  @Type(() => SpecForGeofeature, {
+    keepDiscriminatorProperty: true,
+    discriminator: {
+      property: 'kind',
+      subTypes: [
+        { value: SpecForPlainGeoFeature, name: 'plain' },
+        {
+          value: SpecForGeoFeatureWithGeoprocessing,
+          name: 'withGeoprocessing',
+        },
+      ],
+    },
+  })
+  features!: Array<SpecForPlainGeoFeature | SpecForGeoFeatureWithGeoprocessing>;
+}

api/apps/api/src/modules/geo-features/dto/update.geo-feature-set.dto.ts

@@ -0,0 +1,3 @@
+import { GeoFeatureSetSpecification } from './geo-feature-set-specification.dto';
+
+export class UpdateGeoFeatureSetDTO extends GeoFeatureSetSpecification {}

api/apps/api/src/modules/geo-features/geo-feature-property-sets.service.ts

@@ -0,0 +1,129 @@
+import { apiConnections } from '@marxan-api/ormconfig';
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { flatten } from 'lodash';
+import { In, Repository } from 'typeorm';
+import { inspect } from 'util';
+import { Project } from '../projects/project.api.entity';
+import { Scenario } from '../scenarios/scenario.api.entity';
+import { GeoFeatureSetSpecification } from './dto/geo-feature-set-specification.dto';
+import { GeoFeature } from './geo-feature.api.entity';
+import { GeoFeaturePropertySet } from './geo-feature.geo.entity';
+
+@Injectable()
+export class GeoFeaturePropertySetService {
+  constructor(
+    @InjectRepository(
+      GeoFeaturePropertySet,
+      apiConnections.geoprocessingDB.name,
+    )
+    private readonly geoFeaturePropertySetsRepository: Repository<GeoFeaturePropertySet>,
+    @InjectRepository(GeoFeature)
+    private readonly geoFeaturesRepository: Repository<GeoFeature>,
+    @InjectRepository(Project)
+    private readonly projectRepository: Repository<Project>,
+  ) {}
+
+  getFeaturePropertySetsForFeatures(
+    geoFeatureIds: string[],
+    forProject?: Project | null | undefined,
+  ): Promise<GeoFeaturePropertySet[]> {
+    const query = this.geoFeaturePropertySetsRepository
+      .createQueryBuilder('propertySets')
+      .distinct(true)
+      .where(`propertySets.featureId IN (:...ids)`, { ids: geoFeatureIds });
+
+    if (forProject) {
+      query.andWhere(
+        `st_intersects(
+        st_makeenvelope(:xmin, :ymin, :xmax, :ymax, 4326),
+        "propertySets".bbox
+      )`,
+        {
+          xmin: forProject.bbox[1],
+          ymin: forProject.bbox[3],
+          xmax: forProject.bbox[0],
+          ymax: forProject.bbox[2],
+        },
+      );
+    }
+    return query.getMany();
+  }
+
+  extendGeoFeaturesWithPropertiesFromPropertySets(
+    geoFeatures: GeoFeature[],
+    propertySet: GeoFeaturePropertySet[],
+  ) {
+    return geoFeatures.map((i) => {
+      const propertySetForFeature = propertySet.filter(
+        (ps) => ps.featureId === i.id,
+      );
+      return {
+        ...i,
+        properties: propertySetForFeature.reduce((acc, cur) => {
+          return {
+            ...acc,
+            [cur.key]: [...(acc[cur.key] || []), cur.value[0]],
+          };
+        }, {} as Record<string, Array<string | number>>),
+      };
+    });
+  }
+
+  /**
+   * Add feature metadata to features in a geofeatures processing specification.
+   */
+  async extendGeoFeatureProcessingSpecification(
+    specification: GeoFeatureSetSpecification,
+    scenario: Scenario,
+  ): Promise<any> {
+    const project = await this.projectRepository.findOne(scenario.projectId);
+    const idsOfFeaturesInGeoprocessingOperations = new Set(
+      flatten(
+        specification.features
+          .map((feature) =>
+            feature.geoprocessingOperations
+              ?.map((op) => {
+                if (op.kind === 'stratification/v1') {
+                  return op.intersectWith.featureId;
+                }
+              })
+              .filter((id): id is string => !!id),
+          )
+          .filter((id): id is string[] => !!id),
+      ),
+    );
+    const idsOfTopLevelFeaturesInSpecification = new Set(
+      specification.features.map((feature) => feature.featureId),
+    );
+    const idsOfFeaturesInSpecification = Array.from(
+      new Set([
+        ...idsOfTopLevelFeaturesInSpecification,
+        ...idsOfFeaturesInGeoprocessingOperations,
+      ]),
+    );
+    const featuresInSpecification = await this.geoFeaturesRepository.find({
+      id: In(idsOfFeaturesInSpecification),
+    });
+    Logger.debug(inspect(featuresInSpecification));
+    const metadataForFeaturesInSpecification = await this.getFeaturePropertySetsForFeatures(
+      idsOfFeaturesInSpecification,
+      project,
+    );
+    const featuresInSpecificationWithPropertiesMetadata = this.extendGeoFeaturesWithPropertiesFromPropertySets(
+      featuresInSpecification,
+      metadataForFeaturesInSpecification,
+    );
+    return {
+      status: specification.status,
+      features: specification.features.map((feature) => {
+        return {
+          ...feature,
+          metadata: featuresInSpecificationWithPropertiesMetadata.find(
+            (f) => f.id === feature.featureId,
+          ),
+        };
+      }),
+    };
+  }
+}

api/apps/api/src/modules/geo-features/geo-feature-set.api.entity.ts

@@ -0,0 +1,37 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { BaseServiceResource } from '@marxan-api/types/resource.interface';
+import { GeoFeatureSetSpecification } from './dto/geo-feature-set-specification.dto';
+
+export const geoFeatureResource: BaseServiceResource = {
+  className: 'GeoFeature',
+  name: {
+    singular: 'geo_feature',
+    plural: 'geo_features',
+  },
+  moduleControllerPrefix: 'geo-features',
+};
+
+export enum FeatureTags {
+  bioregional = 'bioregional',
+  species = 'species',
+}
+
+export interface GeoFeatureCategory {
+  key: string;
+  distinctValues: string[];
+}
+export class JSONAPIGeoFeatureSetsData {
+  @ApiProperty()
+  type = geoFeatureResource.name.plural;
+
+  @ApiProperty()
+  id!: string;
+
+  @ApiProperty()
+  attributes!: GeoFeatureSetSpecification;
+}
+
+export class GeoFeatureSetResult {
+  @ApiProperty()
+  data!: JSONAPIGeoFeatureSetsData;
+}

api/apps/api/src/modules/geo-features/geo-feature-set.serializer.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@nestjs/common';
+import { PaginationMeta } from '@marxan-api/utils/app-base.service';
+import { GeoFeatureSetService } from './geo-feature-set.service';
+import { GeoFeatureSetSpecification } from './dto/geo-feature-set-specification.dto';
+
+@Injectable()
+export class GeoFeatureSetSerializer {
+  constructor(private readonly geoFeatureSetsService: GeoFeatureSetService) {}
+
+  async serialize(
+    entities:
+      | Partial<GeoFeatureSetSpecification>
+      | undefined
+      | (Partial<GeoFeatureSetSpecification> | undefined)[],
+    paginationMeta?: PaginationMeta,
+  ): Promise<any> {
+    return this.geoFeatureSetsService.serialize(entities, paginationMeta);
+  }
+}