Merge branch 'feature/Calculos' into develop

src/Controllers/CalculatorController.ts

 import {
   Handler, Request, Response, Router,
 } from 'express';
-import AgeGroupJSON from '../DTOs/AgeGroupJSON';
 import CalculatorService from '../Services/CalculatorService';
 import CalculatorResponse from '../DTOs/CalculatorResponseDTO';
 import logger from '../Logger/logger';
@@ -9,9 +8,10 @@ import logger from '../Logger/logger';
 const router = Router();
 
 const getREP: Handler = async (req: Request, res: Response) => {
-  const groups: AgeGroupJSON[] = req.body;
+  const { groups, extraData } = req.body;
   try {
-    const EnergyReq: CalculatorResponse = CalculatorService.calculateEnergeticRequirement(groups);
+    const EnergyReq:
+    CalculatorResponse = CalculatorService.calculateEnergeticRequirement(groups, extraData);
     return res.status(200).send(EnergyReq);
   } catch (error) {
     const e = error as Error;

src/DTOs/AdultPALDTO.ts

+type AdultPAL = {
+  urbanPercentage: number;
+  activeUrbanPAL: number;
+  lowUrbanPAL: number;
+  ruralPercentage: number;
+  activeRuralPAL: number;
+  lowRuralPAL: number;
+};
+
+export default AdultPAL;

src/DTOs/AgeGroupDTO.ts

@@ -2,10 +2,10 @@ import AgeBracket from '../Enum/AgeBracket';
 import Sex from '../Enum/Sex';
 
 type AgeGroup = {
-  edad: AgeBracket;
-  sexo: Sex;
-  pesoMediano: number;
-  cantidad: number;
+  age: AgeBracket;
+  sex: Sex;
+  medianWeight: number;
+  population: number;
 };
 
 export default AgeGroup;

src/DTOs/AgeGroupJSON.ts

 type AgeGroupJSON = {
-  edad: string;
-  sexo: string;
-  pesoMediano: string;
-  cantidad: string;
+  age: string; // TODO: check enum
+  sex: string;
+  medianWeight: number; // TODO: check if it can be number again
+  population: number; // TODO: check if it can be number again
 };
 
 export default AgeGroupJSON;

src/DTOs/CalculatorResponseDTO.ts

@@ -2,8 +2,8 @@ import EnergeticRequirement from './EnergeticRequirementDTO';
 import GroupEnergeticRequirement from './GroupEnergeticRequirementDTO';
 
 type CalculatorResponse = {
-  requerimientosPorGrupo: GroupEnergeticRequirement[];
-  requerimientoTotal: EnergeticRequirement;
+  groupsRequirements: GroupEnergeticRequirement[];
+  totalRequirement: EnergeticRequirement;
 };
 
 export default CalculatorResponse;

src/DTOs/EnergeticRequirementDTO.ts

 type EnergeticRequirement = {
-  requerimientoEnergeticoPerCapita: number;
-  requerimientoEnergeticoTotal: number;
-  poblacionTotal: number;
+  perCapita: number;
+  total: number;
+  totalPopulation: number;
 };
 
 export default EnergeticRequirement;

src/DTOs/ExtraDataDTO.ts

+import AdultPAL from './AdultPALDTO';
+import IndividualMaternity from './IndividualMaternityDTO';
+import MinorPAL from './MinorPALDTO';
+import PopulationMaternity from './PopulationMaternityDTO';
+
+type ExtraData = {
+  minorPAL: MinorPAL | undefined;
+  adultPAL: AdultPAL | undefined;
+  maternity18To29: IndividualMaternity | PopulationMaternity | undefined;
+  maternity30To59: IndividualMaternity | PopulationMaternity | undefined;
+};
+
+export default ExtraData;

src/DTOs/GroupEnergeticRequirementDTO.ts

 import AgeGroupJSON from './AgeGroupJSON';
 
 type GroupEnergeticRequirement = {
-  grupoEtario: AgeGroupJSON;
-  requerimientoEnergeticoPerCapita: number;
-  requerimientoEnergeticoTotal: number;
+  group: AgeGroupJSON;
+  perCapita: number;
+  total: number;
 };
 
 export default GroupEnergeticRequirement;

src/DTOs/IndividualMaternityDTO.ts

+type IndividualMaternity = {
+  pregnantWomen: number;
+  lactatingWomen: number;
+};
+
+export default IndividualMaternity;

src/DTOs/MinorPALDTO.ts

+type MinorPAL = {
+  lowPALPrevalence: number;
+  moderatePALPrevalence: number;
+  intensePALPrevalence: number;
+};
+
+export default MinorPAL;

src/DTOs/PopulationMaternityDTO.ts

+type PopulationMaternity = {
+  countryBirthRate: number;
+  countryPopulation: number;
+};
+
+export default PopulationMaternity;

src/Enum/ParameterType.ts

 enum ParameterType {
-  NAF = 'NAF',
-  PesoPorDefecto = 'Peso por defecto',
-  EmbarazoYLactancia = 'Embarazo y lactancia',
-  ConstanteDeEcuacion = 'Constante de ecuacion'
+  PAL = 'NAF',
+  DefaultWeight = 'Peso por defecto',
+  Maternity = 'Embarazo y lactancia',
+  EquationConstant = 'Constante de ecuacion'
 }
 
 export default ParameterType;

src/Enum/Sex.ts

 enum Sex {
-  Masculino = 'Masculino',
-  Femenino = 'Femenino',
+  Male = 'Masculino',
+  Female = 'Femenino',
 }
 
 export default Sex;

src/Models/Parameter.ts

+import ParameterType from '../Enum/ParameterType';
+
 class Parameter {
   name: string;
 
   value: number;
 
-  constructor(name: string, value: number) {
+  parameterType: ParameterType;
+
+  constructor(name: string, value: number, parameterType: ParameterType) {
     this.name = name;
     this.value = value;
+    this.parameterType = parameterType;
   }
 }
 

src/Services/CalculatorService.ts

@@ -4,15 +4,17 @@ import ParserService from './ParserService';
 import AgeGroup from '../DTOs/AgeGroupDTO';
 import CalculatorResponse from '../DTOs/CalculatorResponseDTO';
 import AgeGroupJSON from '../DTOs/AgeGroupJSON';
+import ExtraData from '../DTOs/ExtraDataDTO';
 
-const calculateEnergeticRequirement = (data: AgeGroupJSON[]): CalculatorResponse => {
-  const parametros = new Map<number[], AgeGroup>();
-  const ageGroups = ParserService.parseGroups(data);
+// eslint-disable-next-line max-len
+const calculateEnergeticRequirement = (groups: AgeGroupJSON[], data: ExtraData): CalculatorResponse => {
+  const parameters = new Map<number[], AgeGroup>();
+  const ageGroups = ParserService.parseGroups(groups);
   ageGroups.forEach((group: AgeGroup) => {
-    parametros.set(ParameterService.getEquationValues(group.edad, group.sexo), group);
+    parameters.set(ParameterService.getEquationValues(group.age, group.sex), group);
   });
 
-  const res: CalculatorResponse = ERCalculator.calculateER(parametros);
+  const res: CalculatorResponse = ERCalculator.calculateER(parameters, data);
 
   return res;
 };

src/Services/ERCalculator.ts

@@ -2,46 +2,231 @@ import AgeGroup from '../DTOs/AgeGroupDTO';
 import EnergeticRequirement from '../DTOs/EnergeticRequirementDTO';
 import CalculatorResponse from '../DTOs/CalculatorResponseDTO';
 import GroupEnergeticRequirement from '../DTOs/GroupEnergeticRequirementDTO';
-import ParserService from './ParserService';
+import ExtraData from '../DTOs/ExtraDataDTO';
+import MinorPAL from '../DTOs/MinorPALDTO';
+import AdultPAL from '../DTOs/AdultPALDTO';
+import IndividualMaternity from '../DTOs/IndividualMaternityDTO';
+import PopulationMaternity from '../DTOs/PopulationMaternityDTO';
+import Sex from '../Enum/Sex';
 import AgeBracket from '../Enum/AgeBracket';
+import ParserService from './ParserService';
+
+// eslint-disable-next-line max-len
+const isIndividualMaternity = (obj: IndividualMaternity | PopulationMaternity): obj is IndividualMaternity => {
+  if ((obj as IndividualMaternity).pregnantWomen) {
+    return true;
+  }
+  return false;
+};
+
+// TEE (Total Energetic Expenditure) = GET (Gasto Energetico Total)
+const calculateTEE = (group: AgeGroup, params: number[], preval: MinorPAL): number => {
+  const teeModerate: number = params[0]
+  + (params[1] * group.medianWeight)
+  - params[2] * (group.medianWeight * group.medianWeight);
+
+  const teeLow: number = teeModerate - (teeModerate * params[4]) / 100;
+  const teeIntense: number = teeModerate + (teeModerate * params[5]) / 100;
+
+  const ret: number = (teeLow * preval.lowPALPrevalence) / 100
+  + (teeModerate * preval.moderatePALPrevalence) / 100
+  + (teeIntense * preval.intensePALPrevalence) / 100;
+
+  return ret;
+};
+
+// BMR (Basal Metabolic Rate) = TMB (Tasa Metabolica Basal)
+const calculateBMR = (group: AgeGroup, params: number[]): number => {
+  const ret: number = params[0] * group.medianWeight + params[1];
+  return ret;
+};
+
+// PAL (Physical Activity Level) = NAF (Nivel de Actividad Fisica)
+const calculatePAL = (params: number[], popData: AdultPAL): number => {
+  const ruralPAL: number = (popData.activeRuralPAL * params[2]) / 100
+  + (popData.lowRuralPAL * params[3]) / 100;
+  const urbanPAL: number = (popData.activeUrbanPAL * params[4]) / 100
+  + (popData.lowUrbanPAL * params[5]) / 100;
+
+  const ret = (ruralPAL * popData.ruralPercentage) / 100
+  + (urbanPAL * popData.urbanPercentage) / 100;
+  return ret;
+};
+
+// eslint-disable-next-line max-len
+const calculateERWomenIndividual = (group: AgeGroup, params: number[], popData: IndividualMaternity, req: number): number => {
+  const percentPregnantWomen = (popData.pregnantWomen * 100) / group.population;
+  const percentLactatingWomen = (popData.lactatingWomen * 100) / group.population;
+
+  const reqPregnantWomen = (percentPregnantWomen * (req + params[6])) / 100;
+  const reqLactatingWomen = (percentLactatingWomen * (req + params[7])) / 100;
+  const reqRestOfWomen = ((100 - percentPregnantWomen - percentLactatingWomen) * req) / 100;
+
+  return reqPregnantWomen + reqLactatingWomen + reqRestOfWomen;
+};
+
+// eslint-disable-next-line max-len
+const calculateERWomenPopulation = (group: AgeGroup, params: number[], popData: PopulationMaternity, req: number): number => {
+  const annualBirths = popData.countryBirthRate * popData.countryPopulation;
+
+  const percentPregnantWomen = (annualBirths * 75) / group.population;
+  const percentLactatingWomen = (annualBirths * 50) / group.population;
+
+  const reqPregnantWomen = (percentPregnantWomen * (req + params[6])) / 100;
+  const reqLactatingWomen = (percentLactatingWomen * (req + params[7])) / 100;
+  const reqRestOfWomen = ((100 - percentPregnantWomen - percentLactatingWomen) * req) / 100;
+
+  return reqPregnantWomen + reqLactatingWomen + reqRestOfWomen;
+};
 
 const calculateLessThanAYear = (group: AgeGroup, params: number[]): GroupEnergeticRequirement => {
-  const requirement = params[0] + (params[1] * group.pesoMediano) + params[2];
+  const requirement = params[0] + (params[1] * group.medianWeight) + params[2];
 
   const groupRequirement: GroupEnergeticRequirement = {
-    grupoEtario: ParserService.unparseGroup(group),
-    requerimientoEnergeticoPerCapita: requirement,
-    requerimientoEnergeticoTotal: requirement * group.cantidad,
+    group: ParserService.unparseGroup(group),
+    perCapita: requirement,
+    total: requirement * group.population,
   };
 
   return groupRequirement;
 };
 
-const calculateOneToFiveYears = (group: AgeGroup, params: number[]): GroupEnergeticRequirement => {
+const calculate1To5Years = (group: AgeGroup, params: number[]): GroupEnergeticRequirement => {
   const requirement = params[0]
-  + (params[1] * group.pesoMediano)
-  + (params[2] * (group.pesoMediano ** 2))
+  + (params[1] * group.medianWeight)
+  + (params[2] * (group.medianWeight ** 2))
   + params[3];
 
   const groupRequirement: GroupEnergeticRequirement = {
-    grupoEtario: ParserService.unparseGroup(group),
-    requerimientoEnergeticoPerCapita: requirement,
-    requerimientoEnergeticoTotal: requirement * group.cantidad,
+    group: ParserService.unparseGroup(group),
+    perCapita: requirement,
+    total: requirement * group.population,
   };
 
   return groupRequirement;
 };
 
-const calculateER = (groupParameters: Map<number[], AgeGroup>): CalculatorResponse => {
+// eslint-disable-next-line max-len
+const calculate6To17Years = (group: AgeGroup, params: number[], data: ExtraData): GroupEnergeticRequirement => {
+  let tee: number;
+  if (typeof (data.minorPAL) === 'undefined') {
+    throw new Error('Missing data');
+  } else {
+    tee = calculateTEE(group, params, data.minorPAL);
+  }
+
+  const requirement = tee + params[3];
+
+  const groupRequirement: GroupEnergeticRequirement = {
+    group: ParserService.unparseGroup(group),
+    perCapita: requirement,
+    total: requirement * group.population,
+  };
+
+  return groupRequirement;
+};
+
+// eslint-disable-next-line max-len
+const calculate18To29Years = (group: AgeGroup, params: number[], data: ExtraData): GroupEnergeticRequirement => {
+  let bmr: number;
+  let pal: number;
+  if (typeof (data.adultPAL) === 'undefined') {
+    throw new Error('Missing data');
+  } else {
+    bmr = calculateBMR(group, params);
+    pal = calculatePAL(params, data.adultPAL);
+  }
+
+  let requirement: number = bmr * pal;
+
+  // If the group's sex is Female, then you have to take into account
+  // the extra energy required by women that are pregnant or lactating
+  if (group.sex === Sex.Female) {
+    if (data.maternity18To29 === undefined) {
+      throw new Error('Missing data');
+    } else if (isIndividualMaternity(data.maternity18To29)) {
+      requirement = calculateERWomenIndividual(group, params, data.maternity18To29, requirement);
+    } else {
+      requirement = calculateERWomenPopulation(group, params, data.maternity18To29, requirement);
+    }
+  }
+
+  const groupRequirement: GroupEnergeticRequirement = {
+    group: ParserService.unparseGroup(group),
+    perCapita: requirement,
+    total: requirement * group.population,
+  };
+
+  return groupRequirement;
+};
+
+// eslint-disable-next-line max-len
+const calculate30To59Years = (group: AgeGroup, params: number[], data: ExtraData): GroupEnergeticRequirement => {
+  let bmr: number;
+  let pal: number;
+  if (typeof (data.adultPAL) === 'undefined') {
+    throw new Error('Missing data');
+  } else {
+    bmr = calculateBMR(group, params);
+    pal = calculatePAL(params, data.adultPAL);
+  }
+
+  let requirement: number = bmr * pal;
+
+  // If the group's sex is Female, then you have to take into account
+  // the extra energy required by women that are pregnant or lactating
+  if (group.sex === Sex.Female) {
+    if (typeof (data.maternity30To59) === 'undefined') {
+      throw new Error('Missing data');
+    } else if (isIndividualMaternity(data.maternity30To59)) {
+      requirement = calculateERWomenIndividual(group, params, data.maternity30To59, requirement);
+    } else {
+      requirement = calculateERWomenPopulation(group, params, data.maternity30To59, requirement);
+    }
+  }
+
+  const groupRequirement: GroupEnergeticRequirement = {
+    group: ParserService.unparseGroup(group),
+    perCapita: requirement,
+    total: requirement * group.population,
+  };
+
+  return groupRequirement;
+};
+
+// eslint-disable-next-line max-len
+const calculate60PlusYears = (group: AgeGroup, params: number[], data: ExtraData): GroupEnergeticRequirement => {
+  let bmr: number;
+  let pal: number;
+  if (typeof (data.adultPAL) === 'undefined') {
+    throw new Error('Missing data');
+  } else {
+    bmr = calculateBMR(group, params);
+    pal = calculatePAL(params, data.adultPAL);
+  }
+
+  const requirement: number = bmr * pal;
+
+  const groupRequirement: GroupEnergeticRequirement = {
+    group: ParserService.unparseGroup(group),
+    perCapita: requirement,
+    total: requirement * group.population,
+  };
+
+  return groupRequirement;
+};
+
+// eslint-disable-next-line max-len
+const calculateER = (groupParameters: Map<number[], AgeGroup>, data: ExtraData): CalculatorResponse => {
   let totalOfPeople = 0;
   let totalRequirement = 0;
 
   const requirements: GroupEnergeticRequirement[] = [];
 
   groupParameters.forEach((group: AgeGroup, params: number[]) => {
-    totalOfPeople += group.cantidad;
+    totalOfPeople += group.population;
     let groupRequirement: GroupEnergeticRequirement;
-    switch (group.edad) {
+    switch (group.age) {
       case AgeBracket.m0:
       case AgeBracket.m1:
       case AgeBracket.m2:
@@ -62,26 +247,53 @@ const calculateER = (groupParameters: Map<number[], AgeGroup>): CalculatorRespon
       case AgeBracket.a3:
       case AgeBracket.a4:
       case AgeBracket.a5: {
-        groupRequirement = calculateOneToFiveYears(group, params);
+        groupRequirement = calculate1To5Years(group, params);
+        break;
+      }
+      case AgeBracket.a6:
+      case AgeBracket.a7:
+      case AgeBracket.a8:
+      case AgeBracket.a9:
+      case AgeBracket.a10:
+      case AgeBracket.a11:
+      case AgeBracket.a12:
+      case AgeBracket.a13:
+      case AgeBracket.a14:
+      case AgeBracket.a15:
+      case AgeBracket.a16:
+      case AgeBracket.a17: {
+        groupRequirement = calculate6To17Years(group, params, data);
+        break;
+      }
+      case AgeBracket.a18_29: {
+        groupRequirement = calculate18To29Years(group, params, data);
+        break;
+      }
+      case AgeBracket.a30_59: {
+        groupRequirement = calculate30To59Years(group, params, data);
+        break;
+      }
+      case AgeBracket.a60: {
+        groupRequirement = calculate60PlusYears(group, params, data);
         break;
       }
       default: {
         throw new Error('Parsing error, attribute edad does not respect format');
       }
     }
-    totalRequirement += groupRequirement.requerimientoEnergeticoTotal;
+    totalRequirement += groupRequirement.total;
     requirements.push(groupRequirement);
   });
 
   const totalER: EnergeticRequirement = {
-    requerimientoEnergeticoPerCapita: totalRequirement / totalOfPeople,
-    requerimientoEnergeticoTotal: totalRequirement,
-    poblacionTotal: totalOfPeople,
+    perCapita: totalRequirement / totalOfPeople,
+    total: totalRequirement,
+    totalPopulation: totalOfPeople,
   };
 
   const result: CalculatorResponse = {
-    requerimientosPorGrupo: requirements,
-    requerimientoTotal: totalER,
+    groupsRequirements: requirements,
+    totalRequirement: totalER,
   };
 
   return result;

src/Services/ParameterService.ts

@@ -7,177 +7,328 @@ const getEquationValues = (ageBracket: AgeBracket, sex: Sex): number[] => {
   let res: number[] = [];
   switch (ageBracket) {
     case (AgeBracket.m0): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // -152 + (92.8*MP) + 211
         res = [-152, 92.8, 211];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // -152 + (92.8*MP) + 178
         res = [-152, 92.8, 178];
       }
       break;
     }
     case (AgeBracket.m1): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // -152 + (92.8*MP) + 183
         res = [-152, 92.8, 183];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // -152 + (92.8*MP) + 161
         res = [-152, 92.8, 161];
       }
       break;
     }
     case (AgeBracket.m2): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // -152 + (92.8*MP) + 139
         res = [-152, 92.8, 139];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // -152 + (92.8*MP) + 134
         res = [-152, 92.8, 134];
       }
       break;
     }
     case (AgeBracket.m3): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // -152 + (92.8*MP) + 53
         res = [-152, 92.8, 53];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // -152 + (92.8*MP) + 68
         res = [-152, 92.8, 68];
       }
       break;
     }
     case (AgeBracket.m4): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // -152 + (92.8*MP) + 46
         res = [-152, 92.8, 46];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // -152 + (92.8*MP) + 57
         res = [-152, 92.8, 57];
       }
       break;
     }
     case (AgeBracket.m5): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // -152 + (92.8*MP) + 36
         res = [-152, 92.8, 36];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // -152 + (92.8*MP) + 47
         res = [-152, 92.8, 47];
       }
       break;
     }
     case (AgeBracket.m6): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // -99.4 + (88.6*MP) + 17
         res = [-99.4, 88.6, 17];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // -99.4 + (88.6*MP) + 20
         res = [-99.4, 88.6, 20];
       }
       break;
     }
     case (AgeBracket.m7): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // -99.4 + (88.6*MP) + 16
         res = [-99.4, 88.6, 16];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // -99.4 + (88.6*MP) + 17
         res = [-99.4, 88.6, 17];
       }
       break;
     }
     case (AgeBracket.m8): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // -99.4 + (88.6*MP) + 14
         res = [-99.4, 88.6, 14];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // -99.4 + (88.6*MP) + 15
         res = [-99.4, 88.6, 15];
       }
       break;
     }
     case (AgeBracket.m9): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // -99.4 + (88.6*MP) + 21
         res = [-99.4, 88.6, 21];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // -99.4 + (88.6*MP) + 18
         res = [-99.4, 88.6, 18];
       }
       break;
     }
     case (AgeBracket.m10): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // -99.4 + (88.6*MP) + 21
         res = [-99.4, 88.6, 21];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // -99.4 + (88.6*MP) + 15
         res = [-99.4, 88.6, 15];
       }
       break;
     }
     case (AgeBracket.m11): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // -99.4 + (88.6*MP) + 22
         res = [-99.4, 88.6, 22];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // -99.4 + (88.6*MP) + 14
         res = [-99.4, 88.6, 14];
       }
       break;
     }
     case (AgeBracket.a1): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // 310.2 + (63.3*MP) - 0.263*MP^2 + 13
         res = [310.2, 63.3, -0.263, 13];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // 263.4 + (65.3*MP) - 0.454*MP^2 + 13
         res = [263.4, 65.3, -0.454, 13];
       }
       break;
     }
     case (AgeBracket.a2): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // 310.2 + (63.3*MP) - 0.263*MP^2 + 12
         res = [310.2, 63.3, -0.263, 12];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // 263.4 + (65.3*MP) - 0.454*MP^2 + 13
         res = [263.4, 65.3, -0.454, 13];
       }
       break;
     }
     case (AgeBracket.a3): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // 310.2 + (63.3*MP) - 0.263*MP^2 + 12
         res = [310.2, 63.3, -0.263, 12];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // 263.4 + (65.3*MP) - 0.454*MP^2 + 11
         res = [263.4, 65.3, -0.454, 11];
       }
       break;
     }
     case (AgeBracket.a4): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // 310.2 + (63.3*MP) - 0.263*MP^2 + 11
         res = [310.2, 63.3, -0.263, 11];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // 263.4 + (65.3*MP) - 0.454*MP^2 + 10
         res = [263.4, 65.3, -0.454, 10];
       }
       break;
     }
     case (AgeBracket.a5): {
-      if (sex === Sex.Masculino) {
+      if (sex === Sex.Male) {
         // 310.2 + (63.3*MP) - 0.263*MP^2 + 11
         res = [310.2, 63.3, -0.263, 11];
-      } else if (sex === Sex.Femenino) {
+      } else if (sex === Sex.Female) {
         // 263.4 + (65.3*MP) - 0.454*MP^2 + 10
         res = [263.4, 65.3, -0.454, 10];
       }
       break;
     }
+    case (AgeBracket.a6): {
+      if (sex === Sex.Male) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 11, -15%/+15% for light/intense TEE
+        res = [310.2, 63.3, -0.263, 12, 15, 15];
+      } else if (sex === Sex.Female) {
+        // 263.4 + (65.3*MP) - 0.454*MP^2 + 10, -15%/+15% for light/intense TEE
+        res = [263.4, 65.3, -0.454, 13, 15, 15];
+      }
+      break;
+    }
+    case (AgeBracket.a7): {
+      if (sex === Sex.Male) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 14, -15%/+15% for light/intense TEE
+        res = [310.2, 63.3, -0.263, 14, 15, 15];
+      } else if (sex === Sex.Female) {
+        // 263.4 + (65.3*MP) - 0.454*MP^2 + 17, -15%/+15% for light/intense TEE
+        res = [263.4, 65.3, -0.454, 17, 15, 15];
+      }
+      break;
+    }
+    case (AgeBracket.a8): {
+      if (sex === Sex.Male) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 16, -15%/+15% for light/intense TEE
+        res = [310.2, 63.3, -0.263, 16, 15, 15];
+      } else if (sex === Sex.Female) {
+        // 263.4 + (65.3*MP) - 0.454*MP^2 + 20, -15%/+15% for light/intense TEE
+        res = [263.4, 65.3, -0.454, 20, 15, 15];
+      }
+      break;
+    }
+    case (AgeBracket.a9): {
+      if (sex === Sex.Male) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 19, -15%/+15% for light/intense TEE
+        res = [310.2, 63.3, -0.263, 19, 15, 15];
+      } else if (sex === Sex.Female) {
+        // 263.4 + (65.3*MP) - 0.454*MP^2 + 23, -15%/+15% for light/intense TEE
+        res = [263.4, 65.3, -0.454, 23, 15, 15];
+      }
+      break;
+    }
+    case (AgeBracket.a10): {
+      if (sex === Sex.Male) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 22, -15%/+15% for light/intense TEE
+        res = [310.2, 63.3, -0.263, 22, 15, 15];
+      } else if (sex === Sex.Female) {
+        // 263.4 + (65.3*MP) - 0.454*MP^2 + 25, -15%/+15% for light/intense TEE
+        res = [263.4, 65.3, -0.454, 25, 15, 15];
+      }
+      break;
+    }
+    case (AgeBracket.a11): {
+      if (sex === Sex.Male) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 25, -15%/+15% for light/intense TEE
+        res = [310.2, 63.3, -0.263, 25, 15, 15];
+      } else if (sex === Sex.Female) {
+        // 263.4 + (65.3*MP) - 0.454*MP^2 + 25, -15%/+15% for light/intense TEE
+        res = [263.4, 65.3, -0.454, 25, 15, 15];
+      }
+      break;
+    }
+    case (AgeBracket.a12): {
+      if (sex === Sex.Male) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 29, -15%/+15% for light/intense TEE
+        res = [310.2, 63.3, -0.263, 29, 15, 15];
+      } else if (sex === Sex.Female) {
+        // 263.4 + (65.3*MP) - 0.454*MP^2 + 26, -15%/+15% for light/intense TEE
+        res = [263.4, 65.3, -0.454, 26, 15, 15];
+      }
+      break;
+    }
+    case (AgeBracket.a13): {
+      if (sex === Sex.Male) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 33, -15%/+15% for light/intense TEE
+        res = [310.2, 63.3, -0.263, 33, 15, 15];
+      } else if (sex === Sex.Female) {
+        // 263.4 + (65.3*MP) - 0.454*MP^2 + 24, -15%/+15% for light/intense TEE
+        res = [263.4, 65.3, -0.454, 24, 15, 15];
+      }
+      break;
+    }
+    case (AgeBracket.a14): {
+      if (sex === Sex.Male) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 33, -15%/+15% for light/intense TEE
+        res = [310.2, 63.3, -0.263, 33, 15, 15];
+      } else if (sex === Sex.Female) {
+        // 263.4 + (65.3*MP) - 0.454*MP^2 + 19, -15%/+15% for light/intense TEE
+        res = [263.4, 65.3, -0.454, 19, 15, 15];
+      }
+      break;
+    }
+    case (AgeBracket.a15): {
+      if (sex === Sex.Male) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 31, -15%/+15% for light/intense TEE
+        res = [310.2, 63.3, -0.263, 31, 15, 15];
+      } else if (sex === Sex.Female) {
+        // 263.4 + (65.3*MP) - 0.454*MP^2 + 13, -15%/+15% for light/intense TEE
+        res = [263.4, 65.3, -0.454, 13, 15, 15];
+      }
+      break;
+    }
+    case (AgeBracket.a16): {
+      if (sex === Sex.Male) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 24, -15%/+15% for light/intense TEE
+        res = [310.2, 63.3, -0.263, 24, 15, 15];
+      } else if (sex === Sex.Female) {
+        // 263.4 + (65.3*MP) - 0.454*MP^2 + 5, -15%/+15% for light/intense TEE
+        res = [263.4, 65.3, -0.454, 5, 15, 15];
+      }
+      break;
+    }
+    case (AgeBracket.a17): {
+      if (sex === Sex.Male) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 14, -15%/+15% for light/intense TEE
+        res = [310.2, 63.3, -0.263, 14, 15, 15];
+      } else if (sex === Sex.Female) {
+        // 263.4 + (65.3*MP) - 0.454*MP^2 + 0, -15%/+15% for light/intense TEE
+        res = [263.4, 65.3, -0.454, 0, 15, 15];
+      }
+      break;
+    }
+    case (AgeBracket.a18_29): {
+      if (sex === Sex.Male) {
+        // (15.057*MP + 692.2) * PAL
+        res = [15.057, 692.2, 1.95, 1.65, 1.85, 1.55];
+      } else if (sex === Sex.Female) {
+        // (14.818*MP + 486.6) * PAL, 208 and 251 extra energy for pregnant and lactating women
+        res = [14.818, 486.6, 1.95, 1.65, 1.85, 1.55, 208, 251];
+      }
+      break;
+    }
+    case (AgeBracket.a30_59): {
+      if (sex === Sex.Male) {
+        // (11.472*MP + 873.1) * PAL
+        res = [11.472, 873.1, 1.95, 1.65, 1.85, 1.55];
+      } else if (sex === Sex.Female) {
+        // (8.126*MP + 845.6) * PAL, 208 and 251 extra energy for pregnant and lactating women
+        res = [8.126, 845.6, 1.95, 1.65, 1.85, 1.55, 208, 251];
+      }
+      break;
+    }
+    case (AgeBracket.a60): {
+      if (sex === Sex.Male) {
+        // (11.711*MP + 587.7) * PAL
+        res = [11.711, 587.7, 1.95, 1.65, 1.85, 1.55];
+      } else if (sex === Sex.Female) {
+        // (9.082*MP + 658.5) * PAL
+        res = [9.082, 658.5, 1.95, 1.65, 1.85, 1.55];
+      }
+      break;
+    }
+
     default: {
-      throw new Error('Parsing error, attribute edad does not respect format');
+      throw new Error(`Parsing error, attribute edad does not respect format ${ageBracket}`);
     }
   }
   return res;

src/Services/ParserService.ts

@@ -161,16 +161,16 @@ import Sex from '../Enum/Sex';
 
 const parseGroups = (groups: AgeGroupJSON[]): AgeGroup[] => {
   const retGroups: AgeGroup[] = [];
-  groups.forEach((obj: AgeGroupJSON) => {
+  groups.forEach((ageGroup: AgeGroupJSON) => {
     // if (typeof (obj.pesoMediano) !== 'number' || typeof (obj.cantidad) !== 'number') {
     //  console.log('Estas haciendo cualquiera flaco');
     //  throw new Error('Parsing error, attributes do not respect format');
     // }
     const group: AgeGroup = {
-      edad: obj.edad as AgeBracket,
-      sexo: obj.sexo as Sex,
-      pesoMediano: parseFloat(obj.pesoMediano),
-      cantidad: parseFloat(obj.cantidad),
+      age: ageGroup.age as AgeBracket,
+      sex: ageGroup.sex as Sex,
+      medianWeight: ageGroup.medianWeight,
+      population: ageGroup.population,
     };
     retGroups.push(group);
   });
@@ -179,10 +179,10 @@ const parseGroups = (groups: AgeGroupJSON[]): AgeGroup[] => {
 
 const unparseGroup = (group: AgeGroup): AgeGroupJSON => {
   const retGroup: AgeGroupJSON = {
-    edad: group.edad as string,
-    sexo: group.sexo as string,
-    pesoMediano: String(group.pesoMediano),
-    cantidad: String(group.cantidad),
+    age: group.age as string,
+    sex: group.sex as string,
+    medianWeight: group.medianWeight,
+    population: group.population,
   };
   return retGroup;
 };

swagger.yaml

@@ -46,19 +46,21 @@ paths:
         - BearerAuth: []
 
   /repCalculator:
-      post:
-        tags:
-          - Calculation
+    post:
+      tags:
+        - Calculation
       summary: Given population data calculates its energetic requirement
       requestBody:
         content: 
           application/json:
             schema:
-              $ref: '#/components/schemas/AgeGroupJSON'
+              $ref: '#/components/schemas/ReqCalculation'
         required: true
       responses:
         '200':
           description: Ok.
+        '400':
+          description: Bad request.
       security:
         - BearerAuth: []
 components:
@@ -107,11 +109,92 @@ components:
           type: string
     AgeGroupJSON:
       properties:
-        edad:
+        age:
           type: string
-        sexo:
+        sex:
           type: string
-        pesoMediano:
+        medianWeight:
           type: string
-        cantidad:
-          type: string
\ No newline at end of file
+        population:
+          type: string
+      required:
+        - age
+        - sex
+        - medianWeight
+        - population
+    MinorPAL:
+      properties:
+        lowPALPrevalence:
+          type: number
+        moderatePALPrevalence:
+          type: number
+        intensePALPrevalence:
+          type: number
+      required:
+        - lowPALPrevalence
+        - moderatePALPrevalence
+        - intensePALPrevalence
+    AdultPAL:
+      properties:
+        urbanPercentage:
+          type: number
+        activeUrbanPAL:
+          type: number
+        lowUrbanPAL:
+          type: number
+        ruralPercentage:
+          type: number
+        activeRuralPAL:
+          type: number
+        lowRuralPAL:
+          type: number
+      required:
+        - urbanPercentage
+        - activeUrbanPAL
+        - lowUrbanPAL
+        - ruralPercentage
+        - activeRuralPAL
+        - lowRuralPAL
+    IndividualMaternity:
+      properties:
+        pregnantWomen:
+          type: number
+        lactatingWomen:
+          type: number
+      required:
+        - pregnantWomen
+        - lactatingWomen
+    PopulationMaternity:
+      properties:
+        countryBirthRate:
+          type: number
+        countryPopulation:
+          type: number
+      required:
+        - countryBirthRate
+        - countryPopulation
+    ExtraData:
+      properties:
+        minorPAL:
+          $ref: '#/components/schemas/MinorPAL'
+        adultPAL:
+          $ref: '#/components/schemas/AdultPAL'
+        maternity18to29:
+          oneOf:
+            - $ref: '#/components/schemas/IndividualMaternity'
+            - $ref: '#/components/schemas/PopulationMaternity'
+        maternity30to59:
+          oneOf:
+            - $ref: '#/components/schemas/IndividualMaternity'
+            - $ref: '#/components/schemas/PopulationMaternity'
+    ReqCalculation:
+      properties:
+        groups:
+          type: array
+          items:
+            $ref: '#/components/schemas/AgeGroupJSON'
+        extraData:
+          $ref: '#/components/schemas/ExtraData'
+      required:
+        - groups
+        - extraData
\ No newline at end of file