SIMSBIOHUB-569/589: Add Method Techniques and Manage Sampling Information Page

.github/workflows/addComments.yml

@@ -5,6 +5,7 @@ on:
   pull_request:
     types: [opened, ready_for_review]
     branches-ignore:
+      - test
       - prod
 
 jobs:

api/.vscode/settings.json

@@ -1,3 +1,4 @@
 {
-  "editor.defaultFormatter": "esbenp.prettier-vscode"
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "typescript.preferences.importModuleSpecifier": "non-relative"
 }

api/src/database/db-utils.ts

@@ -1,3 +1,4 @@
+import { DatabaseError } from 'pg';
 import { z } from 'zod';
 import { SYSTEM_IDENTITY_SOURCE } from '../constants/database';
 import { ApiExecuteSQLError } from '../errors/api-error';
@@ -59,6 +60,8 @@ export const syncErrorWrapper =
 /**
  * This function parses the passed in error and translates them into a human readable error
  *
+ * @see https://www.postgresql.org/docs/current/errcodes-appendix.html for postgres error codes
+ *
  * @param error error to be parsed
  * @returns an error to throw
  */
@@ -67,10 +70,17 @@ const parseError = (error: any) => {
     throw new ApiExecuteSQLError('SQL response failed schema check', [error]);
   }
 
-  if (error.message === 'CONCURRENCY_EXCEPTION') {
-    // error thrown by DB trigger based on revision_count
-    // will be thrown if two updates to the same record are made concurrently
-    throw new ApiExecuteSQLError('Failed to update stale data', [error]);
+  if (error instanceof DatabaseError) {
+    if (error.message === 'CONCURRENCY_EXCEPTION') {
+      // error thrown by DB trigger based on revision_count
+      // will be thrown if two updates to the same record are made concurrently
+      throw new ApiExecuteSQLError('Failed to update stale data', [error]);
+    }
+
+    if (error.code === '23503') {
+      // error thrown by DB when query fails due to foreign key constraint
+      throw new ApiExecuteSQLError('Failed to delete record due to foreign key constraint', [error]);
+    }
   }
 
   // Generic error thrown if not captured above

api/src/openapi/schemas/technique.ts

@@ -0,0 +1,154 @@
+import { OpenAPIV3 } from 'openapi-types';
+
+const techniqueAttractantsSchema: OpenAPIV3.SchemaObject = {
+  type: 'array',
+  description: 'Attractants used to lure species during the technique.',
+  items: {
+    type: 'object',
+    required: ['attractant_lookup_id'],
+    additionalProperties: false,
+    properties: {
+      attractant_lookup_id: {
+        type: 'integer',
+        description: 'The ID of a known attractant type.'
+      }
+    }
+  }
+};
+
+const techniqueAttributesSchema: OpenAPIV3.SchemaObject = {
+  type: 'object',
+  description: 'Attributes of the technique.',
+  required: ['qualitative_attributes', 'quantitative_attributes'],
+  additionalProperties: false,
+  properties: {
+    quantitative_attributes: {
+      type: 'array',
+      items: {
+        type: 'object',
+        required: ['method_technique_attribute_quantitative_id', 'method_lookup_attribute_quantitative_id', 'value'],
+        additionalProperties: false,
+        properties: {
+          method_technique_attribute_quantitative_id: {
+            type: 'integer',
+            description: 'Primary key of the attribute.',
+            nullable: true
+          },
+          method_lookup_attribute_quantitative_id: {
+            type: 'string',
+            format: 'uuid',
+            description: 'The ID of a known quantitative attribute.'
+          },
+          value: {
+            type: 'number',
+            description: 'The value of the quantitative attribute.'
+          }
+        }
+      }
+    },
+    qualitative_attributes: {
+      type: 'array',
+      items: {
+        type: 'object',
+        required: [
+          'method_technique_attribute_qualitative_id',
+          'method_lookup_attribute_qualitative_id',
+          'method_lookup_attribute_qualitative_option_id'
+        ],
+        additionalProperties: false,
+        properties: {
+          method_technique_attribute_qualitative_id: {
+            type: 'integer',
+            description: 'Primary key of the attribute',
+            nullable: true
+          },
+          method_lookup_attribute_qualitative_id: {
+            type: 'string',
+            format: 'uuid',
+            description: 'The ID of a known qualitative attribute.'
+          },
+          method_lookup_attribute_qualitative_option_id: {
+            type: 'string',
+            format: 'uuid',
+            description: 'The ID of a known qualitative attribute option.'
+          }
+        }
+      }
+    }
+  }
+};
+
+export const techniqueSimpleViewSchema: OpenAPIV3.SchemaObject = {
+  type: 'object',
+  required: ['method_technique_id', 'name', 'description', 'attractants'],
+  additionalProperties: false,
+  properties: {
+    method_technique_id: {
+      type: 'integer',
+      description: 'Primary key of the technique'
+    },
+    name: {
+      type: 'string',
+      description: 'Name of the technique.'
+    },
+    description: {
+      type: 'string',
+      description: 'Description of the technique.',
+      nullable: true
+    },
+    attractants: techniqueAttractantsSchema
+  }
+};
+
+export const techniqueCreateSchema: OpenAPIV3.SchemaObject = {
+  type: 'object',
+  required: ['name', 'description', 'method_lookup_id', 'distance_threshold', 'attractants', 'attributes'],
+  additionalProperties: false,
+  properties: {
+    name: {
+      type: 'string',
+      description: 'Name of the technique.'
+    },
+    description: {
+      type: 'string',
+      description: 'Description of the technique.',
+      nullable: true
+    },
+    method_lookup_id: {
+      type: 'integer',
+      description: 'The ID of a known method type.',
+      minimum: 1
+    },
+    distance_threshold: {
+      type: 'number',
+      description: 'Maximum detection distance (meters).',
+      nullable: true
+    },
+    attractants: techniqueAttractantsSchema,
+    attributes: techniqueAttributesSchema
+  }
+};
+
+export const techniqueUpdateSchema: OpenAPIV3.SchemaObject = {
+  ...techniqueCreateSchema,
+  required: [...(techniqueCreateSchema.required ?? []), 'method_technique_id'],
+  properties: {
+    ...techniqueCreateSchema.properties,
+    method_technique_id: {
+      type: 'number',
+      description: 'Primary key for the technique.'
+    }
+  }
+};
+
+export const techniqueViewSchema: OpenAPIV3.SchemaObject = {
+  ...techniqueCreateSchema,
+  required: [...(techniqueCreateSchema.required ?? []), 'method_technique_id'],
+  properties: {
+    ...techniqueCreateSchema.properties,
+    method_technique_id: {
+      type: 'number',
+      description: 'Primary key for the technique.'
+    }
+  }
+};

api/src/paths/codes.test.ts

@@ -5,45 +5,31 @@ import sinonChai from 'sinon-chai';
 import * as db from '../database/db';
 import { HTTPError } from '../errors/http-error';
 import { CodeService } from '../services/code-service';
-import { getMockDBConnection } from '../__mocks__/db';
+import { getMockDBConnection, getRequestHandlerMocks } from '../__mocks__/db';
 import * as codes from './codes';
 
 chai.use(sinonChai);
 
 describe('codes', () => {
-  const dbConnectionObj = getMockDBConnection();
-
-  const sampleReq = {
-    keycloak_token: {}
-  } as any;
-
-  let actualResult = {
-    management_action_type: null
-  };
-
-  const sampleRes = {
-    status: () => {
-      return {
-        json: (result: any) => {
-          actualResult = result;
-        }
-      };
-    }
-  };
-
   describe('getAllCodes', () => {
     afterEach(() => {
       sinon.restore();
     });
 
     it('should throw a 500 error when fails to fetch codes', async () => {
+      const dbConnectionObj = getMockDBConnection();
       sinon.stub(db, 'getAPIUserDBConnection').returns(dbConnectionObj);
+
       sinon.stub(CodeService.prototype, 'getAllCodeSets').resolves(undefined);
 
+      const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
+
+      mockReq.keycloak_token = {};
+
       try {
-        const result = codes.getAllCodes();
+        const requestHandler = codes.getAllCodes();
 
-        await result(sampleReq, null as unknown as any, null as unknown as any);
+        await requestHandler(mockReq, mockRes, mockNext);
         expect.fail();
       } catch (actualError) {
         expect((actualError as HTTPError).status).to.equal(500);
@@ -52,28 +38,40 @@ describe('codes', () => {
     });
 
     it('should return the fetched codes on success', async () => {
+      const dbConnectionObj = getMockDBConnection();
       sinon.stub(db, 'getAPIUserDBConnection').returns(dbConnectionObj);
+
       sinon.stub(CodeService.prototype, 'getAllCodeSets').resolves({
         management_action_type: { id: 1, name: 'management action type' }
       } as any);
 
-      const result = codes.getAllCodes();
+      const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
 
-      await result(sampleReq, sampleRes as any, null as unknown as any);
+      mockReq.keycloak_token = {};
 
-      expect(actualResult.management_action_type).to.eql({ id: 1, name: 'management action type' });
+      const requestHandler = codes.getAllCodes();
+
+      await requestHandler(mockReq, mockRes, mockNext);
+
+      expect(mockRes.jsonValue.management_action_type).to.eql({ id: 1, name: 'management action type' });
     });
 
     it('should throw an error when a failure occurs', async () => {
       const expectedError = new Error('cannot process request');
 
+      const dbConnectionObj = getMockDBConnection();
       sinon.stub(db, 'getAPIUserDBConnection').returns(dbConnectionObj);
+
       sinon.stub(CodeService.prototype, 'getAllCodeSets').rejects(expectedError);
 
+      const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
+
+      mockReq.keycloak_token = {};
+
       try {
-        const result = codes.getAllCodes();
+        const requestHandler = codes.getAllCodes();
 
-        await result(sampleReq, sampleRes as any, null as unknown as any);
+        await requestHandler(mockReq, mockRes, mockNext);
         expect.fail();
       } catch (actualError) {
         expect((actualError as HTTPError).message).to.equal(expectedError.message);

api/src/paths/codes.ts

@@ -37,7 +37,8 @@ GET.apiDoc = {
               'vantage_codes',
               'site_selection_strategies',
               'survey_progress',
-              'method_response_metrics'
+              'method_response_metrics',
+              'attractants'
             ],
             properties: {
               management_action_type: {
@@ -316,11 +317,13 @@ GET.apiDoc = {
               },
               survey_progress: {
                 type: 'array',
+                description: 'Indicates the progress of a survey (e.g. planned, in progress, completed).',
                 items: {
                   type: 'object',
                   properties: {
                     id: {
-                      type: 'integer'
+                      type: 'integer',
+                      minimum: 1
                     },
                     name: {
                       type: 'string'
@@ -333,13 +336,37 @@ GET.apiDoc = {
               },
               method_response_metrics: {
                 type: 'array',
+                description:
+                  'Indicates the measurement type of a sampling method (e.g. count, precent cover, biomass, etc).',
                 items: {
                   type: 'object',
                   additionalProperties: false,
                   required: ['id', 'name', 'description'],
                   properties: {
                     id: {
-                      type: 'integer'
+                      type: 'integer',
+                      minimum: 1
+                    },
+                    name: {
+                      type: 'string'
+                    },
+                    description: {
+                      type: 'string'
+                    }
+                  }
+                }
+              },
+              attractants: {
+                type: 'array',
+                description: 'Describes the attractants that can be used by a sampling technique.',
+                items: {
+                  type: 'object',
+                  additionalProperties: false,
+                  required: ['id', 'name', 'description'],
+                  properties: {
+                    id: {
+                      type: 'integer',
+                      minimum: 1
                     },
                     name: {
                       type: 'string'
@@ -395,6 +422,9 @@ export function getAllCodes(): RequestHandler {
         throw new HTTP500('Failed to fetch codes');
       }
 
+      // Allow browsers to cache this response for 300 seconds (5 minutes)
+      res.setHeader('Cache-Control', 'private, max-age=300');
+
       return res.status(200).json(allCodeSets);
     } catch (error) {
       defaultLog.error({ label: 'getAllCodes', message: 'error', error });

api/src/paths/project/{projectId}/delete.ts

@@ -14,7 +14,7 @@ export const DELETE: Operation = [
     return {
       or: [
         {
-          validProjectPermissions: [PROJECT_PERMISSION.COORDINATOR],
+          validProjectPermissions: [PROJECT_PERMISSION.COORDINATOR, PROJECT_PERMISSION.COLLABORATOR],
           projectId: Number(req.params.projectId),
           discriminator: 'ProjectPermission'
         },