Upload summary results

api/src/models/survey-view.ts

@@ -31,6 +31,7 @@ export class GetViewSurveyDetailsData {
   completion_status: string;
   publish_date: string;
   occurrence_submission_id: number;
+  summary_results_submission_id: number;
 
   constructor(surveyDetailsData?: any) {
     defaultLog.debug({ label: 'GetViewSurveyDetailsData', message: 'params', surveyDetailsData });
@@ -72,6 +73,7 @@ export class GetViewSurveyDetailsData {
 
     this.id = surveyDataItem?.id ?? null;
     this.occurrence_submission_id = surveyDataItem?.occurrence_submission_id ?? null;
+    this.summary_results_submission_id = surveyDataItem?.summary_results_submission_id ?? null;
     this.survey_name = surveyDataItem?.name || '';
     this.survey_purpose = surveyDataItem?.objectives || '';
     this.focal_species = (focalSpeciesList.length && focalSpeciesList.filter((item: string | number) => !!item)) || [];

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

@@ -1,5 +1,4 @@
 'use strict';
-
 import { RequestHandler } from 'express';
 import { Operation } from 'express-openapi';
 import { SYSTEM_ROLE } from '../../../../../../constants/roles';

api/src/paths/project/{projectId}/survey/{surveyId}/summary/submission/get.ts

@@ -0,0 +1,139 @@
+'use strict';
+
+import { RequestHandler } from 'express';
+import { Operation } from 'express-openapi';
+import { SYSTEM_ROLE } from '../../../../../../../constants/roles';
+import { getDBConnection } from '../../../../../../../database/db';
+import { HTTP400 } from '../../../../../../../errors/CustomError';
+import { getLatestSurveySummarySubmissionSQL } from '../../../../../../../queries/survey/survey-summary-queries';
+import { getLogger } from '../../../../../../../utils/logger';
+
+const defaultLog = getLogger('/api/project/{projectId}/survey/{surveyId}/summary/submission/get');
+
+export const GET: Operation = [getSurveySummarySubmission()];
+
+GET.apiDoc = {
+  description: 'Fetches an observation occurrence submission for a survey.',
+  tags: ['observation_submission'],
+  security: [
+    {
+      Bearer: [SYSTEM_ROLE.SYSTEM_ADMIN, SYSTEM_ROLE.PROJECT_ADMIN]
+    }
+  ],
+  parameters: [
+    {
+      in: 'path',
+      name: 'projectId',
+      schema: {
+        type: 'number'
+      },
+      required: true
+    },
+    {
+      in: 'path',
+      name: 'surveyId',
+      schema: {
+        type: 'number'
+      },
+      required: true
+    }
+  ],
+  responses: {
+    200: {
+      description: 'Observation submission get response.',
+      content: {
+        'application/json': {
+          schema: {
+            type: 'object',
+            properties: {
+              id: {
+                type: 'number'
+              },
+              fileName: {
+                description: 'The file name of the submission',
+                type: 'string'
+              },
+              status: {
+                description: 'The validation status of the submission',
+                type: 'string'
+              },
+              messages: {
+                description: 'The validation status messages of the submission',
+                type: 'array',
+                items: {
+                  type: 'object',
+                  description: 'A validation status message of the submission'
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    400: {
+      $ref: '#/components/responses/400'
+    },
+    401: {
+      $ref: '#/components/responses/401'
+    },
+    403: {
+      $ref: '#/components/responses/401'
+    },
+    500: {
+      $ref: '#/components/responses/500'
+    },
+    default: {
+      $ref: '#/components/responses/default'
+    }
+  }
+};
+
+export function getSurveySummarySubmission(): RequestHandler {
+  return async (req, res) => {
+    defaultLog.debug({ label: 'Get a survey summary result', message: 'params', req_params: req.params });
+
+    if (!req.params.surveyId) {
+      throw new HTTP400('Missing required path param `surveyId`');
+    }
+
+    const connection = getDBConnection(req['keycloak_token']);
+
+    try {
+      const getSurveySummarySubmissionSQLStatement = getLatestSurveySummarySubmissionSQL(Number(req.params.surveyId));
+
+      if (!getSurveySummarySubmissionSQLStatement) {
+        throw new HTTP400('Failed to build SQL getLatestSurveySummarySubmissionSQLStatement statement');
+      }
+
+      await connection.open();
+
+      const summarySubmissionData = await connection.query(
+        getSurveySummarySubmissionSQLStatement.text,
+        getSurveySummarySubmissionSQLStatement.values
+      );
+
+      if (!summarySubmissionData || !summarySubmissionData.rows || !summarySubmissionData.rows[0]) {
+        return res.status(200).json(null);
+      }
+
+      await connection.commit();
+
+      const getSummarySubmissionData =
+        (summarySubmissionData &&
+          summarySubmissionData.rows &&
+          summarySubmissionData.rows[0] && {
+            id: summarySubmissionData.rows[0].survey_summary_submission_id,
+            fileName: summarySubmissionData.rows[0].file_name
+          }) ||
+        null;
+
+      return res.status(200).json(getSummarySubmissionData);
+    } catch (error) {
+      defaultLog.debug({ label: 'getSummarySubmissionData', message: 'error', error });
+      await connection.rollback();
+      throw error;
+    } finally {
+      connection.release();
+    }
+  };
+}

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

@@ -0,0 +1,226 @@
+'use strict';
+import { RequestHandler } from 'express';
+import { Operation } from 'express-openapi';
+import { SYSTEM_ROLE } from '../../../../../../../constants/roles';
+import { getDBConnection, IDBConnection } from '../../../../../../../database/db';
+import { HTTP400 } from '../../../../../../../errors/CustomError';
+import {
+  insertSurveySummarySubmissionSQL,
+  updateSurveySummarySubmissionWithKeySQL
+} from '../../../../../../../queries/survey/survey-summary-queries';
+import { generateS3FileKey, scanFileForVirus, uploadFileToS3 } from '../../../../../../../utils/file-utils';
+import { getLogger } from '../../../../../../../utils/logger';
+import { logRequest } from '../../../../../../../utils/path-utils';
+
+const defaultLog = getLogger('/api/project/{projectId}/survey/{surveyId}/summary/upload');
+
+export const POST: Operation = [
+  logRequest('paths/project/{projectId}/survey/{surveyId}/summary/upload', 'POST'),
+  uploadMedia()
+];
+
+POST.apiDoc = {
+  description: 'Upload survey results file.',
+  tags: ['results'],
+  security: [
+    {
+      Bearer: [SYSTEM_ROLE.SYSTEM_ADMIN, SYSTEM_ROLE.PROJECT_ADMIN]
+    }
+  ],
+  parameters: [
+    {
+      in: 'path',
+      name: 'projectId',
+      required: true
+    },
+    {
+      in: 'path',
+      name: 'surveyId',
+      required: true
+    }
+  ],
+  requestBody: {
+    description: 'Survey summary results file to upload',
+    content: {
+      'multipart/form-data': {
+        schema: {
+          type: 'object',
+          properties: {
+            media: {
+              description: 'A survey summary file.',
+              type: 'string',
+              format: 'binary'
+            }
+          }
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: 'Upload OK'
+    },
+    400: {
+      $ref: '#/components/responses/400'
+    },
+    401: {
+      $ref: '#/components/responses/401'
+    },
+    403: {
+      $ref: '#/components/responses/401'
+    },
+    500: {
+      $ref: '#/components/responses/500'
+    },
+    default: {
+      $ref: '#/components/responses/default'
+    }
+  }
+};
+
+/**
+ * Uploads a media file to S3 and inserts a matching record in the `occurrence_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 || !rawMediaArray.length) {
+      // no media objects included, skipping media upload step
+      throw new HTTP400('Missing upload data');
+    }
+
+    defaultLog.debug({
+      label: 'uploadMedia',
+      message: 'files',
+      files: rawMediaArray.map((item) => {
+        return { ...item, buffer: 'Too big to print' };
+      })
+    });
+
+    if (rawMediaArray.length !== 1) {
+      // no media objects included
+      throw new HTTP400('Too many files uploaded, expected 1');
+    }
+
+    if (!req.params.projectId) {
+      throw new HTTP400('Missing required path param: projectId');
+    }
+
+    if (!req.params.surveyId) {
+      throw new HTTP400('Missing required path param: surveyId');
+    }
+
+    const connection = getDBConnection(req['keycloak_token']);
+
+    try {
+      const rawMediaFile = rawMediaArray[0];
+
+      await connection.open();
+
+      // Scan file for viruses using ClamAV
+      const virusScanResult = await scanFileForVirus(rawMediaFile);
+
+      if (!virusScanResult) {
+        throw new HTTP400('Malicious content detected, upload cancelled');
+      }
+
+      const response = await insertSurveySummarySubmission(
+        Number(req.params.surveyId),
+        'BioHub',
+        rawMediaFile.originalname,
+        connection
+      );
+
+      const summarySubmissionId = response.rows[0].id;
+
+      const key = generateS3FileKey({
+        projectId: Number(req.params.projectId),
+        surveyId: Number(req.params.surveyId),
+        folder: `summaryresults/${summarySubmissionId}`,
+        fileName: rawMediaFile.originalname
+      });
+
+      await updateSurveySummarySubmissionWithKey(summarySubmissionId, key, connection);
+
+      await connection.commit();
+
+      const metadata = {
+        filename: rawMediaFile.originalname,
+        username: (req['auth_payload'] && req['auth_payload'].preferred_username) || '',
+        email: (req['auth_payload'] && req['auth_payload'].email) || ''
+      };
+
+      await uploadFileToS3(rawMediaFile, key, metadata);
+
+      return res.status(200).send({ summarySubmissionId });
+    } catch (error) {
+      defaultLog.debug({ label: 'uploadMedia', message: 'error', error });
+      await connection.rollback();
+      throw error;
+    } finally {
+      connection.release();
+    }
+  };
+}
+
+/**
+ * Inserts a new record into the `survey_summary_submission` table.
+ *
+ * @param {number} surveyId
+ * @param {string} source
+ * @param {string} key
+ * @param {IDBConnection} connection
+ * @return {*}  {Promise<void>}
+ */
+export const insertSurveySummarySubmission = async (
+  surveyId: number,
+  source: string,
+  file_name: string,
+  connection: IDBConnection
+): Promise<any> => {
+  const insertSqlStatement = insertSurveySummarySubmissionSQL(surveyId, source, file_name);
+
+  if (!insertSqlStatement) {
+    throw new HTTP400('Failed to build SQL insert statement');
+  }
+
+  const insertResponse = await connection.query(insertSqlStatement.text, insertSqlStatement.values);
+
+  if (!insertResponse || !insertResponse.rowCount) {
+    throw new HTTP400('Failed to insert survey summary submission record');
+  }
+
+  return insertResponse;
+};
+
+/**
+ * Update existing `survey_summary_submission` record with key.
+ *
+ * @param {number} surveyId
+ * @param {string} source
+ * @param {string} key
+ * @param {IDBConnection} connection
+ * @return {*}  {Promise<void>}
+ */
+export const updateSurveySummarySubmissionWithKey = async (
+  submissionId: number,
+  key: string,
+  connection: IDBConnection
+): Promise<any> => {
+  const updateSqlStatement = updateSurveySummarySubmissionWithKeySQL(submissionId, key);
+
+  if (!updateSqlStatement) {
+    throw new HTTP400('Failed to build SQL update statement');
+  }
+
+  const updateResponse = await connection.query(updateSqlStatement.text, updateSqlStatement.values);
+
+  if (!updateResponse || !updateResponse.rowCount) {
+    throw new HTTP400('Failed to update survey summary submission record');
+  }
+
+  return updateResponse;
+};