Loader half done, and getParametersOfType

src/Config/DBConfig.ts

@@ -2,6 +2,6 @@ export const DBConfig = {
   HOST: 'localhost',
   USER: 'root',
   PASSWORD: 'password',
-  DB: 'testdb',
+  DB: 'parameter_database',
   dialect: 'mysql',
 };

src/Controllers/ParameterController.ts

@@ -2,11 +2,21 @@ import {
   Handler, Request, Response, Router,
 } from 'express';
 import ParameterType from '../Enum/ParameterType';
+import logger from '../Logger/logger';
+import ParameterService from '../Services/ParameterService';
 
 const router = Router();
 
 const getParametersOfType: Handler = async (req: Request, res: Response) => {
-  res.send();
+  const paramType: string = req.body;
+  try {
+    const parameters = await ParameterService.getParametersOfType(paramType as ParameterType);
+    return res.status(200).send(parameters);
+  } catch (error) {
+    const e = error as Error;
+    logger.info(e.message);
+    return res.status(400).json({ error: e.message });
+  }
 };
 
 router.post('/', getParametersOfType);

src/DTOs/ParameterDTO.ts

+import ParameterType from '../Enum/ParameterType';
+
+type ParameterDTO = {
+  id: string;
+  value: number;
+  parameterType: ParameterType;
+};
+
+export default ParameterDTO;

src/Loaders/CSVParser.ts

+import ParameterDTO from '../DTOs/ParameterDTO';
+import ParameterType from '../Enum/ParameterType';
+
+function csvToParameters(csv: string): ParameterDTO[] {
+  const parameters: ParameterDTO[] = [];
+  const lines: string[] = csv.split('\n');
+  lines.forEach((parameter: string) => {
+    const fields = parameter.split(',');
+    parameters.push({
+      id: fields[0],
+      value: parseFloat(fields[1]),
+      parameterType: fields[2] as ParameterType,
+    });
+  });
+  return parameters;
+}
+
+export default { csvToParameters };

src/Loaders/DBLoader.sql

 CREATE TABLE Parameters (
-  id STRING NOT NULL,
+  id VARCHAR(100) NOT NULL,
   value INT NOT NULL,
   parameterType INT NOT NULL,
   PRIMARY KEY (id)

src/Loaders/DataBase.ts

-import fs from 'fs';
-import { Sequelize } from 'sequelize';
-import { DBConfig } from '../Config/DBConfig';
-
-function initDataBase(): Sequelize {
-  const sequelize = new Sequelize(
-    DBConfig.DB,
-    DBConfig.USER,
-    DBConfig.PASSWORD,
-    {
-      host: DBConfig.HOST,
-      dialect: 'mysql',
-      dialectOptions: {
-        multipleStatements: true,
-      },
-    },
-  );
-  const loadQuery: string = fs.readFileSync('/DBLoader.sql').toString();
-  sequelize.query(loadQuery);
-  return sequelize;
-}
-
-export default { initDataBase };

src/Loaders/ParameterDataBase.ts

+import { Sequelize } from 'sequelize';
+import { DBConfig } from '../Config/DBConfig';
+
+const sequelize = new Sequelize(
+  DBConfig.DB,
+  DBConfig.USER,
+  DBConfig.PASSWORD,
+  {
+    host: DBConfig.HOST,
+    dialect: 'mysql',
+    dialectOptions: {
+      multipleStatements: true,
+    },
+  },
+);
+
+export default sequelize;

src/Loaders/ParameterDataBaseLoader.ts

+import fs from 'fs';
+import ParameterDTO from '../DTOs/ParameterDTO';
+import Parameter from '../Models/Parameter';
+import CSVParser from './CSVParser';
+
+function initParameterDataBase(): void {
+  const csv: string = fs.readFileSync('/loader.csv').toString();
+  const parameters: ParameterDTO[] = CSVParser.csvToParameters(csv);
+  Parameter.bulkCreate(parameters);
+}
+
+export default { initParameterDataBase };

src/Mappers/ParameterMapper.ts

+import ParameterDTO from '../DTOs/ParameterDTO';
+import Parameter from '../Models/Parameter';
+
+function parameterToData(parameter: Parameter): ParameterDTO {
+  const res: ParameterDTO = {
+    id: parameter.id,
+    value: parameter.value,
+    parameterType: parameter.parameterType,
+  };
+  return res;
+}
+
+export default { parameterToData };

src/Models/Parameter.ts

+import { Model, DataTypes } from 'sequelize';
 import ParameterType from '../Enum/ParameterType';
+import ParameterAttributes from '../Interfaces/ParameterAttributes';
+import ParameterCreationAttributes from '../Interfaces/ParameterCreationAttributes';
+import sequelize from '../Loaders/ParameterDataBase';
 
-class ParameterModel {
-  name: string;
+class Parameter extends Model<ParameterAttributes, ParameterCreationAttributes>
+  implements ParameterAttributes {
+  id!: string;
 
-  value: number;
+  value!: number;
 
-  parameterType: ParameterType;
-
-  constructor(name: string, value: number, parameterType: ParameterType) {
-    this.name = name;
-    this.value = value;
-    this.parameterType = parameterType;
-  }
+  parameterType!: ParameterType;
 }
 
-export default ParameterModel;
+Parameter.init(
+  {
+    id: {
+      type: DataTypes.STRING,
+      primaryKey: true,
+    },
+    value: DataTypes.NUMBER,
+    parameterType: {
+      type: DataTypes.INTEGER,
+      primaryKey: true,
+    },
+  },
+  { sequelize, modelName: 'Parameter' },
+);
+
+export default Parameter;

src/Models/ParameterModel.ts

-import { Model, DataTypes } from 'sequelize';
-import ParameterType from '../Enum/ParameterType';
-import ParameterAttributes from '../Interfaces/ParameterAttributes';
-import ParameterCreationAttributes from '../Interfaces/ParameterCreationAttributes';
-import sequelize from '../Loaders/DataBase';
-
-class Parameter extends Model<ParameterAttributes, ParameterCreationAttributes>
-  implements ParameterAttributes {
-  id!: string;
-
-  value!: number;
-
-  parameterType!: ParameterType;
-}
-
-Parameter.init(
-  {
-    id: DataTypes.STRING,
-    value: DataTypes.NUMBER,
-    parameterType: DataTypes.INTEGER,
-  },
-  { sequelize, modelName: 'Parameter' },
-);
-
-export default Parameter;

src/Services/ParameterService.ts

+import ParameterDTO from '../DTOs/ParameterDTO';
 import AgeBracket from '../Enum/AgeBracket';
 import ParameterType from '../Enum/ParameterType';
 import Sex from '../Enum/Sex';
+import ParameterMapper from '../Mappers/ParameterMapper';
+import Parameter from '../Models/Parameter';
 // import Parameter from '../Models/Parameter';
 
 const getEquationValues = (ageBracket: AgeBracket, sex: Sex): number[] => {
@@ -334,4 +337,20 @@ const getEquationValues = (ageBracket: AgeBracket, sex: Sex): number[] => {
   return res;
 };
 
-export default { getEquationValues };
+const getParametersOfType = (paramType: ParameterType): ParameterDTO[] => {
+  const res: ParameterDTO[] = [];
+  const params: Promise<Parameter[]> = Parameter.findAll({
+    where: {
+      parameterType: paramType,
+    },
+  });
+  params.then((parameters) => parameters.forEach((param: Parameter) => {
+    res.push(ParameterMapper.parameterToData(param));
+  }))
+    .catch((err) => {
+      throw new Error(err);
+    });
+  return res;
+};
+
+export default { getEquationValues, getParametersOfType };

src/index.ts

@@ -7,7 +7,7 @@ import helmet from 'helmet';
 import YAML from 'yamljs';
 import Routes from './routes';
 import logger from './Logger/logger';
-import DataBase from './Loaders/DataBase';
+import ParameterDataBaseLoader from './Loaders/ParameterDataBaseLoader';
 
 const app: Application = express();
 const PORT = process.env.PORT || 8000;
@@ -34,7 +34,7 @@ app.use(express.raw({
 
 app.use(Routes);
 
-const sequelize = DataBase.initDataBase();
+ParameterDataBaseLoader.initParameterDataBase();
 
 app.listen(PORT, (): void => {
   console.log(`REPP Backend running here 👉 https://localhost:${PORT}`);