SIMSBIOHUB-627: Device Endpoints

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

@@ -29,7 +29,7 @@ export const POST: Operation = [
 
 POST.apiDoc = {
   description: 'Creates a new deployment.',
-  tags: ['deployment', 'critterbase'],
+  tags: ['deployment'],
   security: [
     {
       Bearer: []

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

@@ -61,6 +61,8 @@ POST.apiDoc = {
       'application/json': {
         schema: {
           type: 'object',
+          required: ['deployment_ids'],
+          additionalProperties: false,
           properties: {
             deployment_ids: {
               type: 'array',

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

@@ -0,0 +1,72 @@
+import chai, { expect } from 'chai';
+import { describe } from 'mocha';
+import sinon from 'sinon';
+import sinonChai from 'sinon-chai';
+import * as db from '../../../../../../database/db';
+import { TelemetryDeviceService } from '../../../../../../services/telemetry-services/telemetry-device-service';
+import { getMockDBConnection, getRequestHandlerMocks } from '../../../.././../../__mocks__/db';
+import { deleteDevices } from './delete';
+
+chai.use(sinonChai);
+
+describe('deleteDevices', () => {
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it('should delete all provided device records', async () => {
+    const mockDBConnection = getMockDBConnection({ commit: sinon.stub(), release: sinon.stub() });
+    sinon.stub(db, 'getDBConnection').returns(mockDBConnection);
+
+    const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
+
+    mockReq.params = {
+      projectId: '1',
+      surveyId: '2'
+    };
+    mockReq.body = {
+      device_ids: [3, 4]
+    };
+
+    sinon.stub(TelemetryDeviceService.prototype, 'deleteDevices').resolves();
+
+    const requestHandler = deleteDevices();
+
+    await requestHandler(mockReq, mockRes, mockNext);
+
+    expect(mockRes.statusValue).to.equal(200);
+
+    expect(mockDBConnection.commit).to.have.been.calledOnce;
+    expect(mockDBConnection.release).to.have.been.calledOnce;
+  });
+
+  it('should catch and re-throw an error', async () => {
+    const mockDBConnection = getMockDBConnection({ rollback: sinon.stub(), release: sinon.stub() });
+    sinon.stub(db, 'getDBConnection').returns(mockDBConnection);
+
+    const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
+
+    mockReq.params = {
+      projectId: '1',
+      surveyId: '2'
+    };
+    mockReq.body = {
+      device_ids: [3, 4]
+    };
+
+    const mockError = new Error('test error');
+
+    sinon.stub(TelemetryDeviceService.prototype, 'deleteDevices').rejects(mockError);
+
+    const requestHandler = deleteDevices();
+    try {
+      await requestHandler(mockReq, mockRes, mockNext);
+      expect.fail();
+    } catch (actualError) {
+      expect(actualError).to.eql(mockError);
+
+      expect(mockDBConnection.rollback).to.have.been.calledOnce;
+      expect(mockDBConnection.release).to.have.been.calledOnce;
+    }
+  });
+});

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

@@ -0,0 +1,136 @@
+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 { TelemetryDeviceService } from '../../../../../../services/telemetry-services/telemetry-device-service';
+import { getLogger } from '../../../../../../utils/logger';
+
+const defaultLog = getLogger('paths/project/{projectId}/survey/{surveyId}/devices2/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'
+        }
+      ]
+    };
+  }),
+  deleteDevices()
+];
+
+POST.apiDoc = {
+  description: 'Delete devices.',
+  tags: ['device'],
+  security: [
+    {
+      Bearer: []
+    }
+  ],
+  parameters: [
+    {
+      in: 'path',
+      name: 'projectId',
+      schema: {
+        type: 'integer',
+        minimum: 1
+      },
+      required: true
+    },
+    {
+      in: 'path',
+      name: 'surveyId',
+      schema: {
+        type: 'integer',
+        minimum: 1
+      },
+      required: true
+    }
+  ],
+  requestBody: {
+    description: 'Array of one or more device IDs to delete.',
+    content: {
+      'application/json': {
+        schema: {
+          type: 'object',
+          required: ['device_ids'],
+          additionalProperties: false,
+          properties: {
+            device_ids: {
+              type: 'array',
+              items: {
+                type: 'integer',
+                minimum: 1
+              },
+              minItems: 1
+            }
+          }
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: 'Deletes OK.'
+    },
+    400: {
+      $ref: '#/components/responses/400'
+    },
+    401: {
+      $ref: '#/components/responses/401'
+    },
+    403: {
+      $ref: '#/components/responses/403'
+    },
+    409: {
+      $ref: '#/components/responses/409'
+    },
+    500: {
+      $ref: '#/components/responses/500'
+    },
+    default: {
+      $ref: '#/components/responses/default'
+    }
+  }
+};
+
+/**
+ * Deletes devices.
+ *
+ * @export
+ * @return {*}  {RequestHandler}
+ */
+export function deleteDevices(): RequestHandler {
+  return async (req, res) => {
+    const surveyId = Number(req.params.surveyId);
+    const deviceIds: number[] = req.body.device_ids;
+
+    const connection = getDBConnection(req.keycloak_token);
+
+    try {
+      await connection.open();
+
+      const deviceService = new TelemetryDeviceService(connection);
+
+      await deviceService.deleteDevices(surveyId, deviceIds);
+
+      await connection.commit();
+
+      return res.status(200).send();
+    } catch (error) {
+      defaultLog.error({ label: 'deleteDevices', message: 'error', error });
+      await connection.rollback();
+      throw error;
+    } finally {
+      connection.release();
+    }
+  };
+}

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

@@ -0,0 +1,85 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { getDevices } from '.';
+import * as db from '../../../../../../database/db';
+import { TelemetryDeviceService } from '../../../../../../services/telemetry-services/telemetry-device-service';
+import { getMockDBConnection, getRequestHandlerMocks } from '../../../../../../__mocks__/db';
+
+describe('getDevices', () => {
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it('gets devices in survey', async () => {
+    const mockDBConnection = getMockDBConnection({ release: sinon.stub() });
+    sinon.stub(db, 'getDBConnection').returns(mockDBConnection);
+
+    const mockDevices = [
+      {
+        device_id: 1,
+        survey_id: 66,
+        device_key: 'key',
+        serial: '123456',
+        device_make_id: 1,
+        model: 'ModelX',
+        comment: 'Comment'
+      }
+    ];
+
+    sinon.stub(TelemetryDeviceService.prototype, 'getDevicesForSurvey').resolves(mockDevices);
+    sinon.stub(TelemetryDeviceService.prototype, 'getDevicesCount').resolves(1);
+
+    const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
+
+    mockReq.params = {
+      projectId: '1',
+      surveyId: '2'
+    };
+
+    const requestHandler = getDevices();
+
+    await requestHandler(mockReq, mockRes, mockNext);
+
+    expect(mockRes.json).to.have.been.calledOnceWith({
+      devices: mockDevices,
+      count: 1,
+      pagination: {
+        total: 1,
+        per_page: 1,
+        current_page: 1,
+        last_page: 1,
+        sort: undefined,
+        order: undefined
+      }
+    });
+    expect(mockRes.status).calledOnceWith(200);
+    expect(mockDBConnection.release).to.have.been.calledOnce;
+  });
+
+  it('catches and re-throws errors', async () => {
+    const mockDBConnection = getMockDBConnection({ release: sinon.stub() });
+    sinon.stub(db, 'getDBConnection').returns(mockDBConnection);
+
+    const mockError = new Error('Test error');
+
+    sinon.stub(TelemetryDeviceService.prototype, 'getDevicesForSurvey').rejects(mockError);
+    sinon.stub(TelemetryDeviceService.prototype, 'getDevicesCount').resolves(1);
+
+    const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
+
+    mockReq.params = {
+      projectId: '1',
+      surveyId: '2'
+    };
+
+    const requestHandler = getDevices();
+
+    try {
+      await requestHandler(mockReq, mockRes, mockNext);
+      expect.fail();
+    } catch (actualError) {
+      expect(actualError).to.equal(mockError);
+      expect(mockDBConnection.release).to.have.been.calledOnce;
+    }
+  });
+});