SIMSBIOHUB-579/583: Updated Animal Workflow (Capture, Mortality, Measurements, Profile)

api/src/openapi/schemas/critter.ts

@@ -204,30 +204,6 @@ const quantitativeMeasurmentSchema: OpenAPIV3.SchemaObject = {
   }
 };
 
-export const critterCreateRequestObject: OpenAPIV3.SchemaObject = {
-  title: 'Create critter request object',
-  type: 'object',
-  properties: {
-    critter_id: {
-      type: 'string',
-      format: 'uuid'
-    },
-    animal_id: {
-      type: 'string'
-    },
-    wlh_id: {
-      type: 'string'
-    },
-    itis_tsn: {
-      type: 'integer'
-    },
-    sex: {
-      type: 'string'
-    }
-  },
-  additionalProperties: false
-};
-
 export const critterBulkRequestObject: OpenAPIV3.SchemaObject = {
   title: 'Bulk post request object',
   type: 'object',

api/src/paths/project/{projectId}/survey/{surveyId}/critters/delete.test.ts

@@ -0,0 +1,71 @@
+import Ajv from 'ajv';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import * as db from '../../../../../../database/db';
+import { SurveyCritterService } from '../../../../../../services/survey-critter-service';
+import { getMockDBConnection, getRequestHandlerMocks } from '../../../../../../__mocks__/db';
+import { POST, removeCrittersFromSurvey } from './delete';
+
+describe('critterId openapi schema', () => {
+  const ajv = new Ajv();
+
+  it('DELETE is valid openapi v3 schema', () => {
+    expect(ajv.validateSchema(POST.apiDoc as unknown as object)).to.be.true;
+  });
+});
+
+describe('removeCrittersFromSurvey', () => {
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  const mockDBConnection = getMockDBConnection({ release: sinon.stub() });
+
+  it('removes critter from survey', async () => {
+    sinon.stub(db, 'getDBConnection').returns(mockDBConnection);
+
+    const removeCrittersFromSurveyStub = sinon
+      .stub(SurveyCritterService.prototype, 'removeCrittersFromSurvey')
+      .resolves();
+
+    const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
+    mockReq.body = {
+      critterIds: [2, 3]
+    };
+    mockReq.params = {
+      surveyId: '1'
+    };
+
+    const requestHandler = removeCrittersFromSurvey();
+
+    await requestHandler(mockReq, mockRes, mockNext);
+
+    expect(mockRes.statusValue).to.equal(200);
+    expect(removeCrittersFromSurveyStub).to.have.been.calledOnceWith(1, [2, 3]);
+  });
+
+  it('catches and re-throws errors', async () => {
+    sinon.stub(db, 'getDBConnection').returns(mockDBConnection);
+
+    const mockError = new Error('a test error');
+
+    sinon.stub(SurveyCritterService.prototype, 'removeCrittersFromSurvey').rejects(mockError);
+
+    const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
+    mockReq.body = {
+      critterIds: [2, 3]
+    };
+    mockReq.params = {
+      surveyId: '1'
+    };
+
+    const requestHandler = removeCrittersFromSurvey();
+
+    try {
+      await requestHandler(mockReq, mockRes, mockNext);
+      expect.fail();
+    } catch (actualError) {
+      expect(actualError).to.equal(mockError);
+    }
+  });
+});

api/src/paths/project/{projectId}/survey/{surveyId}/critters/delete.ts

@@ -0,0 +1,116 @@
+import { RequestHandler } from 'express';
+import { Operation } from 'express-openapi';
+import { PROJECT_PERMISSION, SYSTEM_ROLE } from '../../../../../../constants/roles';
+import { getDBConnection } from '../../../../../../database/db';
+import { authorizeRequestHandler } from '../../../../../../request-handlers/security/authorization';
+import { SurveyCritterService } from '../../../../../../services/survey-critter-service';
+import { getLogger } from '../../../../../../utils/logger';
+
+const defaultLog = getLogger('paths/project/{projectId}/survey/{surveyId}/critters/delete');
+
+export const POST: Operation = [
+  authorizeRequestHandler((req) => {
+    return {
+      or: [
+        {
+          validProjectPermissions: [PROJECT_PERMISSION.COORDINATOR, PROJECT_PERMISSION.COLLABORATOR],
+          surveyId: Number(req.params.surveyId),
+          discriminator: 'ProjectPermission'
+        },
+        {
+          validSystemRoles: [SYSTEM_ROLE.DATA_ADMINISTRATOR],
+          discriminator: 'SystemRole'
+        }
+      ]
+    };
+  }),
+  removeCrittersFromSurvey()
+];
+
+POST.apiDoc = {
+  description: 'Removes association of critters from this survey.',
+  tags: ['critterbase'],
+  security: [
+    {
+      Bearer: []
+    }
+  ],
+  parameters: [
+    {
+      in: 'path',
+      name: 'surveyId',
+      schema: {
+        type: 'number'
+      },
+      required: true
+    }
+  ],
+  requestBody: {
+    description: 'Array of survey critter Ids to be deleted.',
+    content: {
+      'application/json': {
+        schema: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['critterIds'],
+          properties: {
+            critterIds: {
+              type: 'array',
+              items: {
+                type: 'integer',
+                minimum: 1,
+                description: 'Survey critter Id.'
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: 'Critter was removed from survey'
+    },
+    400: {
+      $ref: '#/components/responses/400'
+    },
+    401: {
+      $ref: '#/components/responses/401'
+    },
+    403: {
+      $ref: '#/components/responses/403'
+    },
+    500: {
+      $ref: '#/components/responses/500'
+    },
+    default: {
+      $ref: '#/components/responses/default'
+    }
+  }
+};
+
+export function removeCrittersFromSurvey(): RequestHandler {
+  return async (req, res) => {
+    const critterIds = req.body.critterIds;
+    const surveyId = Number(req.params.surveyId);
+
+    const connection = getDBConnection(req['keycloak_token']);
+
+    try {
+      await connection.open();
+
+      const surveyCritterService = new SurveyCritterService(connection);
+      const result = await surveyCritterService.removeCrittersFromSurvey(surveyId, critterIds);
+
+      await connection.commit();
+
+      return res.status(200).json(result);
+    } catch (error) {
+      defaultLog.error({ label: 'removeCritterFromSurvey', message: 'error', error });
+      await connection.rollback();
+      throw error;
+    } finally {
+      connection.release();
+    }
+  };
+}

api/src/paths/project/{projectId}/survey/{surveyId}/critters/index.test.ts

@@ -11,21 +11,24 @@ describe('getCrittersFromSurvey', () => {
     sinon.restore();
   });
 
-  const mockDBConnection = getMockDBConnection({ release: sinon.stub() });
-  const mockSurveyCritter = { critter_id: 123, survey_id: 123, critterbase_critter_id: 'critterbase1' };
-  const mockCBCritter = { critter_id: 'critterbase1' };
-
   it('returns critters from survey', async () => {
+    const mockDBConnection = getMockDBConnection({ release: sinon.stub() });
+
+    const mockSurveyCritter = { critter_id: 123, survey_id: 123, critterbase_critter_id: 'critterbase1' };
+    const mockCBCritter = { critter_id: 'critterbase1' };
+
     const mockGetDBConnection = sinon.stub(db, 'getDBConnection').returns(mockDBConnection);
     const mockGetCrittersInSurvey = sinon
       .stub(SurveyCritterService.prototype, 'getCrittersInSurvey')
       .resolves([mockSurveyCritter]);
     const mockGetMultipleCrittersByIds = sinon
       .stub(CritterbaseService.prototype, 'getMultipleCrittersByIds')
       .resolves([mockCBCritter]);
+
     const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
 
     const requestHandler = getCrittersFromSurvey();
+
     await requestHandler(mockReq, mockRes, mockNext);
 
     expect(mockGetDBConnection.calledOnce).to.be.true;
@@ -37,6 +40,8 @@ describe('getCrittersFromSurvey', () => {
   });
 
   it('returns empty array if no critters in survey', async () => {
+    const mockDBConnection = getMockDBConnection({ release: sinon.stub() });
+
     const mockGetDBConnection = sinon.stub(db, 'getDBConnection').returns(mockDBConnection);
     const mockGetCrittersInSurvey = sinon.stub(SurveyCritterService.prototype, 'getCrittersInSurvey').resolves([]);
 
@@ -51,12 +56,16 @@ describe('getCrittersFromSurvey', () => {
   });
 
   it('catches and re-throws errors', async () => {
+    const mockDBConnection = getMockDBConnection({ release: sinon.stub() });
+
     const mockError = new Error('a test error');
     const mockGetDBConnection = sinon.stub(db, 'getDBConnection').returns(mockDBConnection);
     const mockGetCrittersInSurvey = sinon
       .stub(SurveyCritterService.prototype, 'getCrittersInSurvey')
       .rejects(mockError);
+
     const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
+
     const requestHandler = getCrittersFromSurvey();
 
     try {
@@ -76,30 +85,69 @@ describe('addCritterToSurvey', () => {
     sinon.restore();
   });
 
-  const mockDBConnection = getMockDBConnection({ release: sinon.stub() });
-  const mockCBCritter = { critter_id: 'critterbase1' };
+  it('does not create a new critter', async () => {
+    const mockDBConnection = getMockDBConnection({ release: sinon.stub() });
+
+    const mockSurveyCritter = { survey_critter_id: 123, critterbase_critter_id: 'critterbase1' };
+    const mockCBCritter = { critter_id: 'critterbase1' };
+
+    const mockGetDBConnection = sinon.stub(db, 'getDBConnection').returns(mockDBConnection);
+    const mockAddCritterToSurvey = sinon
+      .stub(SurveyCritterService.prototype, 'addCritterToSurvey')
+      .resolves(mockSurveyCritter.survey_critter_id);
+    const mockCreateCritter = sinon.stub(CritterbaseService.prototype, 'createCritter').resolves();
+
+    const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
+    mockReq.body = mockCBCritter;
+
+    const requestHandler = addCritterToSurvey();
+
+    await requestHandler(mockReq, mockRes, mockNext);
+
+    expect(mockGetDBConnection.calledOnce).to.be.true;
+    expect(mockAddCritterToSurvey.calledOnce).to.be.true;
+    expect(mockCreateCritter.notCalled).to.be.true;
+    expect(mockRes.status).to.have.been.calledWith(201);
+    expect(mockRes.json).to.have.been.calledWith(mockSurveyCritter);
+  });
 
   it('returns critters from survey', async () => {
+    const mockDBConnection = getMockDBConnection({ release: sinon.stub() });
+
+    const mockSurveyCritter = { survey_critter_id: 123, critterbase_critter_id: 'critterbase1' };
+    const mockCBCritter = { critter_id: 'critterbase1' };
+
     const mockGetDBConnection = sinon.stub(db, 'getDBConnection').returns(mockDBConnection);
-    const mockAddCritterToSurvey = sinon.stub(SurveyCritterService.prototype, 'addCritterToSurvey').resolves();
+    const mockAddCritterToSurvey = sinon
+      .stub(SurveyCritterService.prototype, 'addCritterToSurvey')
+      .resolves(mockSurveyCritter.survey_critter_id);
     const mockCreateCritter = sinon.stub(CritterbaseService.prototype, 'createCritter').resolves(mockCBCritter);
+
     const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
 
     const requestHandler = addCritterToSurvey();
+
     await requestHandler(mockReq, mockRes, mockNext);
 
     expect(mockGetDBConnection.calledOnce).to.be.true;
     expect(mockAddCritterToSurvey.calledOnce).to.be.true;
     expect(mockCreateCritter.calledOnce).to.be.true;
     expect(mockRes.status).to.have.been.calledWith(201);
-    expect(mockRes.json).to.have.been.calledWith(mockCBCritter);
+    expect(mockRes.json).to.have.been.calledWith(mockSurveyCritter);
   });
 
   it('catches and re-throws errors', async () => {
+    const mockDBConnection = getMockDBConnection({ release: sinon.stub() });
+
+    const mockCBCritter = { critter_id: 'critterbase1' };
+
     const mockError = new Error('a test error');
     const mockGetDBConnection = sinon.stub(db, 'getDBConnection').returns(mockDBConnection);
     const mockAddCritterToSurvey = sinon.stub(SurveyCritterService.prototype, 'addCritterToSurvey').rejects(mockError);
+    const mockCreateCritter = sinon.stub(CritterbaseService.prototype, 'createCritter').resolves(mockCBCritter);
+
     const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
+
     const requestHandler = addCritterToSurvey();
 
     try {
@@ -108,6 +156,7 @@ describe('addCritterToSurvey', () => {
     } catch (actualError) {
       expect(actualError).to.equal(mockError);
       expect(mockAddCritterToSurvey.calledOnce).to.be.true;
+      expect(mockCreateCritter.calledOnce).to.be.true;
       expect(mockGetDBConnection.calledOnce).to.be.true;
       expect(mockDBConnection.release).to.have.been.called;
     }