SIMSBIOHUB-333: Telemetry Table

api/src/paths/project/{projectId}/survey/{surveyId}/telemetry/upload.ts

@@ -0,0 +1,170 @@
+import { RequestHandler } from 'express';
+import { Operation } from 'express-openapi';
+import { PROJECT_PERMISSION, SYSTEM_ROLE } from '../../../../../../constants/roles';
+import { getDBConnection } from '../../../../../../database/db';
+import { HTTP400 } from '../../../../../../errors/http-error';
+import { authorizeRequestHandler } from '../../../../../../request-handlers/security/authorization';
+import { TelemetryService } from '../../../../../../services/telemetry-service';
+import { scanFileForVirus, uploadFileToS3 } from '../../../../../../utils/file-utils';
+import { getLogger } from '../../../../../../utils/logger';
+
+const defaultLog = getLogger('/api/project/{projectId}/survey/{surveyId}/telemetry/upload');
+
+export const POST: Operation = [
+  authorizeRequestHandler((req) => {
+    return {
+      or: [
+        {
+          validProjectPermissions: [PROJECT_PERMISSION.COORDINATOR, PROJECT_PERMISSION.COLLABORATOR],
+          projectId: Number(req.params.projectId),
+          discriminator: 'ProjectPermission'
+        },
+        {
+          validSystemRoles: [SYSTEM_ROLE.DATA_ADMINISTRATOR],
+          discriminator: 'SystemRole'
+        }
+      ]
+    };
+  }),
+  uploadMedia()
+];
+
+POST.apiDoc = {
+  description: 'Upload survey telemetry submission file.',
+  tags: ['telemetry'],
+  security: [
+    {
+      Bearer: []
+    }
+  ],
+  parameters: [
+    {
+      in: 'path',
+      name: 'projectId',
+      required: true
+    },
+    {
+      in: 'path',
+      name: 'surveyId',
+      required: true
+    }
+  ],
+  requestBody: {
+    description: 'Survey telemetry submission file to upload',
+    content: {
+      'multipart/form-data': {
+        schema: {
+          type: 'object',
+          properties: {
+            media: {
+              description: 'A survey telemetry submission file.',
+              type: 'string',
+              format: 'binary'
+            }
+          }
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: 'Upload OK',
+      content: {
+        'application/json': {
+          schema: {
+            type: 'object',
+            properties: {
+              submissionId: {
+                type: 'number'
+              }
+            }
+          }
+        }
+      }
+    },
+    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'
+    }
+  }
+};
+
+/**
+ * Uploads a media file to S3 and inserts a matching record in the `survey_telemetry_submission` table.
+ *
+ * @return {*}  {RequestHandler}
+ */
+export function uploadMedia(): RequestHandler {
+  return async (req, res) => {
+    const rawMediaArray: Express.Multer.File[] = req.files as Express.Multer.File[];
+
+    if (!rawMediaArray?.length) {
+      // no media objects included, skipping media upload step
+      throw new HTTP400('Missing upload data');
+    }
+
+    if (rawMediaArray.length !== 1) {
+      // no media objects included
+      throw new HTTP400('Too many files uploaded, expected 1');
+    }
+
+    const connection = getDBConnection(req['keycloak_token']);
+
+    try {
+      const rawMediaFile = rawMediaArray[0];
+
+      if (!rawMediaFile?.originalname.endsWith('.csv')) {
+        throw new HTTP400('Invalid file type, expected a CSV file.');
+      }
+
+      await connection.open();
+
+      // Scan file for viruses using ClamAV
+      const virusScanResult = await scanFileForVirus(rawMediaFile);
+
+      if (!virusScanResult) {
+        throw new HTTP400('Malicious content detected, upload cancelled');
+      }
+
+      // Insert a new record in the `survey_telemetry_submission` table
+      const service = new TelemetryService(connection);
+      const { submission_id: submissionId, key } = await service.insertSurveyTelemetrySubmission(
+        rawMediaFile,
+        Number(req.params.projectId),
+        Number(req.params.surveyId)
+      );
+
+      // Upload file to S3
+      const metadata = {
+        filename: rawMediaFile.originalname,
+        username: req['auth_payload']?.preferred_username ?? '',
+        email: req['auth_payload']?.email ?? ''
+      };
+
+      const result = await uploadFileToS3(rawMediaFile, key, metadata);
+
+      defaultLog.debug({ label: 'uploadMedia', message: 'result', result });
+
+      await connection.commit();
+
+      return res.status(200).json({ submissionId });
+    } catch (error) {
+      defaultLog.error({ label: 'uploadMedia', message: 'error', error });
+      await connection.rollback();
+      throw error;
+    } finally {
+      connection.release();
+    }
+  };
+}

api/src/paths/telemetry/deployments.test.ts

@@ -0,0 +1,48 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { BctwService, IManualTelemetry } from '../../services/bctw-service';
+import { getRequestHandlerMocks } from '../../__mocks__/db';
+import { getAllTelemetryByDeploymentIds } from './deployments';
+
+const mockTelemetry = ([
+  {
+    telemetry_manual_id: 1
+  },
+  {
+    telemetry_manual_id: 2
+  }
+] as unknown[]) as IManualTelemetry[];
+
+describe('getAllTelemetryByDeploymentIds', () => {
+  afterEach(() => {
+    sinon.restore();
+  });
+  it('should retrieve both manual and vendor telemetry', async () => {
+    const mockGetTelemetry = sinon
+      .stub(BctwService.prototype, 'getAllTelemetryByDeploymentIds')
+      .resolves(mockTelemetry);
+
+    const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
+    const requestHandler = getAllTelemetryByDeploymentIds();
+
+    await requestHandler(mockReq, mockRes, mockNext);
+
+    expect(mockRes.jsonValue).to.eql(mockTelemetry);
+    expect(mockRes.statusValue).to.equal(200);
+    expect(mockGetTelemetry).to.have.been.calledOnce;
+  });
+  it('should catch error', async () => {
+    const mockError = new Error('test error');
+    const mockGetTelemetry = sinon.stub(BctwService.prototype, 'getAllTelemetryByDeploymentIds').rejects(mockError);
+
+    const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
+    const requestHandler = getAllTelemetryByDeploymentIds();
+
+    try {
+      await requestHandler(mockReq, mockRes, mockNext);
+    } catch (err) {
+      expect(err).to.equal(mockError);
+      expect(mockGetTelemetry).to.have.been.calledOnce;
+    }
+  });
+});

api/src/paths/telemetry/deployments.ts

@@ -0,0 +1,103 @@
+import { RequestHandler } from 'express';
+import { Operation } from 'express-openapi';
+import { authorizeRequestHandler } from '../../request-handlers/security/authorization';
+import { BctwService, getBctwUser } from '../../services/bctw-service';
+import { getLogger } from '../../utils/logger';
+
+const defaultLog = getLogger('paths/telemetry/manual');
+
+export const POST: Operation = [
+  authorizeRequestHandler(() => {
+    return {
+      and: [
+        {
+          discriminator: 'SystemUser'
+        }
+      ]
+    };
+  }),
+  getAllTelemetryByDeploymentIds()
+];
+
+POST.apiDoc = {
+  description: 'Get list of manual and vendor telemetry by deployment ids',
+  tags: ['telemetry'],
+  security: [
+    {
+      Bearer: []
+    }
+  ],
+  responses: {
+    200: {
+      description: 'Manual and Vendor telemetry response object',
+      content: {
+        'application/json': {
+          schema: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                id: { type: 'string' },
+                deployment_id: { type: 'string', format: 'uuid' },
+                telemetry_manual_id: { type: 'string', nullable: true },
+                telemetry_id: { type: 'number', nullable: true },
+                latitude: { type: 'number' },
+                longitude: { type: 'number' },
+                acquisition_date: { type: 'string' },
+                telemetry_type: { type: 'string' }
+              }
+            }
+          }
+        }
+      }
+    },
+    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'
+    }
+  },
+
+  requestBody: {
+    description: 'Request body',
+    required: true,
+    content: {
+      'application/json': {
+        schema: {
+          title: 'BCTW deployment ids',
+          type: 'array',
+          minItems: 1,
+          items: {
+            title: 'BCTW deployment ids',
+            type: 'string',
+            format: 'uuid'
+          }
+        }
+      }
+    }
+  }
+};
+
+export function getAllTelemetryByDeploymentIds(): RequestHandler {
+  return async (req, res) => {
+    const user = getBctwUser(req);
+    const bctwService = new BctwService(user);
+    try {
+      const result = await bctwService.getAllTelemetryByDeploymentIds(req.body);
+      return res.status(200).json(result);
+    } catch (error) {
+      defaultLog.error({ label: 'getAllTelemetryByDeploymentIds', message: 'error', error });
+      throw error;
+    }
+  };
+}

api/src/paths/telemetry/manual/delete.test.ts

@@ -0,0 +1,46 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { BctwService, IManualTelemetry } from '../../../services/bctw-service';
+import { getRequestHandlerMocks } from '../../../__mocks__/db';
+import { deleteManualTelemetry } from './delete';
+
+const mockTelemetry = ([
+  {
+    telemetry_manual_id: 1
+  },
+  {
+    telemetry_manual_id: 2
+  }
+] as unknown[]) as IManualTelemetry[];
+
+describe('deleteManualTelemetry', () => {
+  afterEach(() => {
+    sinon.restore();
+  });
+  it('should retrieve all manual telemetry', async () => {
+    const mockGetTelemetry = sinon.stub(BctwService.prototype, 'deleteManualTelemetry').resolves(mockTelemetry);
+
+    const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
+    const requestHandler = deleteManualTelemetry();
+
+    await requestHandler(mockReq, mockRes, mockNext);
+
+    expect(mockRes.jsonValue).to.eql(mockTelemetry);
+    expect(mockRes.statusValue).to.equal(200);
+    expect(mockGetTelemetry).to.have.been.calledOnce;
+  });
+  it('should catch error', async () => {
+    const mockError = new Error('test error');
+    const mockGetTelemetry = sinon.stub(BctwService.prototype, 'deleteManualTelemetry').rejects(mockError);
+
+    const { mockReq, mockRes, mockNext } = getRequestHandlerMocks();
+    const requestHandler = deleteManualTelemetry();
+
+    try {
+      await requestHandler(mockReq, mockRes, mockNext);
+    } catch (err) {
+      expect(err).to.equal(mockError);
+      expect(mockGetTelemetry).to.have.been.calledOnce;
+    }
+  });
+});