CB2-3295: EVL Feed Endpoint

README.md

@@ -83,10 +83,6 @@ For further information about debugging, please refer to the following documenta
 
 - [Debug process section](https://www.serverless.com/plugins/serverless-offline#usage-with-webpack)
 
-## Testing
-
-[json-serverless](https://github.com/pharindoko/json-serverless) has been added to the repository should we wish to mock external services during development and can be used in conjunction with the `test` environment.
-
 ### Unit
 
 Jest is used for unit testing.

commitlint.config.js

@@ -20,7 +20,7 @@ module.exports = {
       2,
       'always',
       (parsed) => {
-        const ticketNumberFormat = /^cvsb-\d+$/;
+        const ticketNumberFormat = /^cb2-\d+$/;
         // type(scope?): subject
         // we want to ticket number to appear in the commit msg as well as scope when we release
         if (

package.json

@@ -32,7 +32,7 @@
     "lint:report": "npm run lint:analyse -- -f json -o reports/eslint/eslint-report.json",
     "lint": "npm-run-all lint:*",
     "prettier": "prettier --write ./**/*.{js,ts}",
-    "security-checks": "git secrets --scan && git log -p | scanrepo",
+    "security-checks": "git secrets --scan",
     "clean": "rimraf ./.build ./.artifact ./.serverless ./.webpack ./*.zip",
     "compile": "tsc",
     "build:dev": "cross-env API_VERSION=${npm_package_version} NODE_ENV=local serverless webpack",
@@ -52,11 +52,14 @@
     "aws-lambda": "1.0.6",
     "aws-sdk": "2.857.0",
     "express": "4.17.1",
+    "moment": "2.29.3",
     "mysql2": "^2.2.5",
     "serverless-http": "2.6.0",
-    "source-map-support": "0.5.19"
+    "source-map-support": "0.5.19",
+    "zlib": "1.0.5"
   },
   "devDependencies": {
+    "@aws-sdk/types": "3.78.0",
     "@commitlint/cli": "11.0.0",
     "@commitlint/config-conventional": "11.0.0",
     "@dvsa/eslint-config-ts": "2.0.0",
@@ -66,6 +69,7 @@
     "@semantic-release/npm": "9.0.1",
     "@serverless/typescript": "2.17.0",
     "@types/aws-lambda": "8.10.70",
+    "@types/express": "4.17.13",
     "@types/jest": "26.0.20",
     "@types/node": "14.14.20",
     "@types/supertest": "2.0.10",
@@ -82,15 +86,13 @@
     "fork-ts-checker-webpack-plugin": "6.0.8",
     "husky": "4.3.8",
     "jest": "26.6.3",
-    "json-serverless": "1.6.14",
     "npm-run-all": "4.1.5",
     "prettier": "2.2.1",
     "rimraf": "3.0.2",
     "semantic-release": "19.0.2",
     "serverless": "3.17.0",
     "serverless-dotenv-plugin": "3.1.0",
     "serverless-offline": "8.7.0",
-    "serverless-s3-local": "0.6.22",
     "serverless-webpack": "5.3.5",
     "supertest": "6.0.1",
     "ts-jest": "26.4.4",

serverless.yml

@@ -22,7 +22,7 @@ plugins:
 provider:
   profile: ${env:AWS_PROVIDER_PROFILE, 'default'}
   name: aws
-  runtime: nodejs10.x
+  runtime: nodejs14.x
   apiGateway:
     # https://www.serverless.com/framework/docs/deprecations/#LOAD_VARIABLES_FROM_ENV_FILES
     shouldStartNameWithService: true

src/app/databaseService.ts

@@ -1,6 +1,7 @@
 import { FieldPacket, RowDataPacket } from 'mysql2';
 import * as technicalQueries from './queries/technicalRecord';
 import * as testResultsQueries from './queries/testResults';
+import { EVL_QUERY, EVL_VRM_QUERY } from './queries/evlQuery';
 import DatabaseServiceInterface from '../interfaces/DatabaseService';
 import ResultsEvent from '../interfaces/ResultsEvent';
 import VehicleEvent from '../interfaces/VehicleEvent';
@@ -13,7 +14,9 @@ import Plate from '../interfaces/queryResults/technical/plate';
 import TestResult from '../interfaces/queryResults/test/testResult';
 import CustomDefect from '../interfaces/queryResults/test/customDefect';
 import TestDefect from '../interfaces/queryResults/test/testDefect';
+import EvlFeedData from '../interfaces/queryResults/evlFeedData';
 import NotFoundError from '../errors/NotFoundError';
+import EvlEvent from '../interfaces/EvlEvent';
 
 async function getTechnicalRecordDetails(
   technicalRecordQueryResult: TechnicalRecordQueryResult,
@@ -196,13 +199,61 @@ async function getTestResultsByTestId(
   return [result];
 }
 
+function getEvlFeedByVrmDetails(
+  queryResult: [RowDataPacket[], FieldPacket[]],
+): EvlFeedData {
+  const evlFeedQueryResult = queryResult[0][0] as EvlFeedData;
+  if (
+    evlFeedQueryResult === undefined
+  ) {
+    throw new NotFoundError('Test not found');
+  }
+
+  return evlFeedQueryResult;
+}
+
+function getEvlFeedDetails(
+  queryResult: [RowDataPacket[], FieldPacket[]],
+): EvlFeedData[] {
+  const evlFeedQueryResults = queryResult[0] as EvlFeedData[];
+
+  if (evlFeedQueryResults === undefined || evlFeedQueryResults.length === 0) {
+    throw new NotFoundError('No tests found');
+  }
+
+  return evlFeedQueryResults.map((evlFeedQueryResult: EvlFeedData) => evlFeedQueryResult);
+}
+
+async function getEvlFeedByVrm(
+  databaseService: DatabaseServiceInterface,
+  event: EvlEvent,
+): Promise<EvlFeedData[]> {
+  console.info('Using getEvlFeedByVrm');
+  const queryResult = await databaseService.get(EVL_VRM_QUERY, [event.vrm_trm]);
+  const result = getEvlFeedByVrmDetails(queryResult);
+
+  return [result];
+}
+
+async function getEvlFeed(
+  databaseService: DatabaseServiceInterface,
+): Promise<EvlFeedData[]> {
+  console.info('Using getEvlFeed');
+  const queryResult = await databaseService.get(EVL_QUERY, []);
+  return getEvlFeedDetails(queryResult);
+}
+
 export {
   getVehicleDetailsByVrm,
   getVehicleDetailsByVin,
   getVehicleDetailsByTrailerId,
   getTestResultsByVrm,
   getTestResultsByVin,
   getTestResultsByTestId,
+  getEvlFeed,
+  getEvlFeedDetails,
+  getEvlFeedByVrm,
+  getEvlFeedByVrmDetails,
 };
 
 interface VehicleQueryResult extends RowDataPacket {

src/app/evlFeedQueryFunctionFactory.ts

@@ -0,0 +1,18 @@
+import DatabaseService from '../interfaces/DatabaseService';
+import EvlEvent from '../interfaces/EvlEvent';
+import { getEvlFeed, getEvlFeedByVrm } from './databaseService';
+import EvlFeedData from '../interfaces/queryResults/evlFeedData';
+
+export default (
+  event: EvlEvent,
+): ((databaseService: DatabaseService, event: EvlEvent) => Promise<EvlFeedData[]>
+  ) => {
+  if (event.vrm_trm) {
+    console.info('Using getEvlFeedByVrm');
+
+    return getEvlFeedByVrm;
+  }
+
+  console.info('Using getEvlFeed');
+  return getEvlFeed;
+};

src/app/queries/evlQuery.ts

@@ -0,0 +1,5 @@
+const EVL_QUERY = 'SELECT `testExpiryDate`, `vrm_trm`, `certificateNumber` FROM `evl_view`';
+
+const EVL_VRM_QUERY = `${EVL_QUERY} WHERE vrm_trm = ?;`;
+
+export { EVL_QUERY, EVL_VRM_QUERY };

src/domain/enquiryService.ts

@@ -1,11 +1,14 @@
 import VehicleEvent from '../interfaces/VehicleEvent';
 import { validateVehicleEvent, validateResultsEvent } from '../utils/validationService';
+import evlFeedQueryFunctionFactory from '../app/evlFeedQueryFunctionFactory';
 import vehicleQueryFunctionFactory from '../app/vehicleQueryFunctionFactory';
 import testResultsQueryFunctionFactory from '../app/testResultsQueryFunctionFactory';
 import DatabaseService from '../interfaces/DatabaseService';
 import ResultsEvent from '../interfaces/ResultsEvent';
+import EvlEvent from '../interfaces/EvlEvent';
 import VehicleDetails from '../interfaces/queryResults/technical/vehicleDetails';
 import TestResult from '../interfaces/queryResults/test/testResult';
+import EvlFeedData from '../interfaces/queryResults/evlFeedData';
 
 const getVehicleDetails = async (
   event: VehicleEvent,
@@ -28,4 +31,13 @@ const getResultsDetails = async (
   return query(dbService, event);
 };
 
-export { getVehicleDetails, getResultsDetails };
+const getEvlFeedDetails = async (
+  event: EvlEvent,
+  queryFuncFactory: typeof evlFeedQueryFunctionFactory,
+  dbService: DatabaseService,
+): Promise<EvlFeedData[]> => {
+  const query = queryFuncFactory(event);
+  return query(dbService, event);
+};
+
+export { getVehicleDetails, getResultsDetails, getEvlFeedDetails };

src/infrastructure/api/index.ts

@@ -1,20 +1,24 @@
 import AWS from 'aws-sdk';
-import express, { Request } from 'express';
+import express, { Request, Router } from 'express';
 import mysql from 'mysql2/promise';
+import moment from 'moment';
 import vehicleQueryFunctionFactory from '../../app/vehicleQueryFunctionFactory';
 import testResultsQueryFunctionFactory from '../../app/testResultsQueryFunctionFactory';
-import { getResultsDetails, getVehicleDetails } from '../../domain/enquiryService';
+import { getResultsDetails, getVehicleDetails, getEvlFeedDetails } from '../../domain/enquiryService';
 import ParametersError from '../../errors/ParametersError';
 import ResultsEvent from '../../interfaces/ResultsEvent';
 import VehicleEvent from '../../interfaces/VehicleEvent';
+import EvlEvent from '../../interfaces/EvlEvent';
 import DatabaseService from '../databaseService';
 import SecretsManagerService from '../secretsManagerService';
 import NotFoundError from '../../errors/NotFoundError';
 import SecretsManagerServiceInterface from '../../interfaces/SecretsManagerService';
 import LocalSecretsManagerService from '../localSecretsManagerService';
+import evlFeedQueryFunctionFactory from '../../app/evlFeedQueryFunctionFactory';
+import { uploadToS3 } from '../s3BucketService';
 
 const app = express();
-const router = express.Router();
+const router: Router = express.Router();
 
 const { API_VERSION } = process.env;
 
@@ -101,6 +105,45 @@ router.get(
   },
 );
 
+router.get(
+  '/evl',
+  (
+    request: Request<Record<string, unknown>, string | Record<string, unknown>, Record<string, unknown>, EvlEvent>,
+    res,
+  ) => {
+    let secretsManager: SecretsManagerServiceInterface;
+    if (process.env.IS_OFFLINE === 'true') {
+      secretsManager = new LocalSecretsManagerService();
+    } else {
+      secretsManager = new SecretsManagerService(new AWS.SecretsManager());
+    }
+    const fileName = `EVL_GVT_${moment(Date.now()).format('YYYYMMDD')}.csv`;
+    DatabaseService.build(secretsManager, mysql)
+      .then((dbService) => getEvlFeedDetails(request.query, evlFeedQueryFunctionFactory, dbService))
+      .then((result) => {
+        console.log('Generating EVL File Data');
+        const evlFeedProcessedData: string = result.map(
+          (entry) => `${entry.vrm_trm},${entry.certificateNumber},${moment(entry.testExpiryDate).format('DD-MMM-YYYY')}`,
+        ).join('\n');
+
+        uploadToS3(evlFeedProcessedData, fileName, () => {
+          res.status(200);
+          res.contentType('json').send();
+        });
+      })
+      .catch((e: Error) => {
+        if (e instanceof ParametersError) {
+          res.status(400);
+        } else if (e instanceof NotFoundError) {
+          res.status(404);
+        } else {
+          res.status(500);
+        }
+        res.send(`Error Generating EVL Feed Data: ${e.message}`);
+      });
+  },
+);
+
 router.all(/testResults|vehicle/, (_request, res) => {
   res.status(405).send();
 });

src/infrastructure/s3BucketService.ts

@@ -0,0 +1,26 @@
+import AWS from 'aws-sdk';
+
+export function uploadToS3(evlFeedProcessedData: string, fileName: string, callback: () => void) {
+  const s3 = configureS3();
+  const params = { Bucket: process.env.AWS_S3_BUCKET_NAME, Key: fileName, Body: evlFeedProcessedData };
+
+  console.log(`uploading ${fileName} to S3`);
+  s3.upload(params, (err) => {
+    if (err) {
+      console.log(err);
+    }
+    callback();
+  });
+}
+
+function configureS3() {
+  if (process.env.IS_OFFLINE === 'true') {
+    return new AWS.S3({
+      s3ForcePathStyle: true,
+      accessKeyId: 'S3RVER', // This specific key is required when working offline
+      secretAccessKey: 'S3RVER',
+      endpoint: 'http://localhost:4569',
+    });
+  }
+  return new AWS.S3();
+}

src/interfaces/EvlEvent.ts

@@ -0,0 +1,3 @@
+export default interface EvlEvent {
+  vrm_trm?: string | undefined;
+}

src/interfaces/queryResults/evlFeedData.ts

@@ -0,0 +1,5 @@
+export default interface EvlFeedData {
+  certificateNumber?: string | undefined;
+  testExpiryDate?: string | undefined;
+  vrm_trm?: string | undefined;
+}

src/resources/changelog-master.xml

@@ -7,4 +7,6 @@
     <include  file="../../cvs-nop/sql/00000_base_database.sql" relativeToChangelogFile="true"/>
     <include  file="../../cvs-nop/sql/00001_base_database_adr.sql" relativeToChangelogFile="true"/>
     <include  file="data-seed.sql" relativeToChangelogFile="true"/>
+    <include  file="../../cvs-nop/sql/00002_views.sql" relativeToChangelogFile="true"/>
+
 </databaseChangeLog>

tests/unit/app/evlFeedQueryFunctionFactory.test.ts

@@ -0,0 +1,28 @@
+import { mocked } from 'ts-jest/utils';
+import queryFunctionFactory from '../../../src/app/evlFeedQueryFunctionFactory';
+import * as dbFunctions from '../../../src/app/databaseService';
+import DatabaseService from '../../../src/infrastructure/databaseService';
+
+jest.mock('../../../src/app/databaseService');
+jest.mock('../../../src/infrastructure/databaseService');
+
+const dbFunctionsMock = mocked(dbFunctions);
+const dbServiceMock = (mocked(DatabaseService, true) as unknown) as DatabaseService;
+
+describe('Query Function Factory', () => {
+  it('returns the correct function when passed a vin', () => {
+    dbFunctionsMock.getEvlFeedByVrm = jest.fn().mockReturnValue('Success');
+
+    const func = queryFunctionFactory({ vrm_trm: '1234' });
+
+    expect(func(dbServiceMock, { vrm_trm: '1234' })).toEqual('Success');
+  });
+
+  it('return the correct function when passed no parameter', () => {
+    dbFunctionsMock.getEvlFeed = jest.fn().mockReturnValue('Success');
+
+    const func = queryFunctionFactory({});
+
+    expect(func(dbServiceMock, {})).toEqual('Success');
+  });
+});