Language change (except enum's String)

src/DTOs/AdultPALDTO.ts

 type AdultPAL = {
-  porcentajeUrbano: number;
-  NAFActivosUrbano: number;
-  NAFLivianaUrbano: number;
-  porcentajeRural: number;
-  NAFActivosRural: number;
-  NAFLivianaRural: number;
+  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;
+  sex: string;
+  medianWeight: string;
+  population: string;
 };
 
 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

@@ -4,9 +4,9 @@ import MinorPAL from './MinorPALDTO';
 import PopulationMaternity from './PopulationMaternityDTO';
 
 type ExtraData = {
-  prevalenciaAFMenores: MinorPAL | undefined;
-  prevalenciaAFAdultos: AdultPAL | undefined;
-  datosEmbarazoLactancia: IndividualMaternity | PopulationMaternity | undefined;
+  minorPAL: MinorPAL | undefined;
+  adultPAL: AdultPAL | undefined;
+  maternity: 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 = {
-  mujeresEmbarazadas: number;
-  mujeresLactando: number;
-  mujeresEmbarazadasLactando: number;
+  pregnants: number;
+  lactating: number;
 };
 
 export default IndividualMaternity;

src/DTOs/MinorPALDTO.ts

 type MinorPAL = {
-  NAFLiviano: number;
-  NAFModerado: number;
-  NAFIntenso: number;
+  lowPalPrevalence: number;
+  moderatePALPrevalence: number;
+  intensePALPrevalence: number;
 };
 
 export default MinorPAL;

src/DTOs/PopulationMaternityDTO.ts

 type PopulationMaternity = {
-  tasaNatalidadPais: number;
-  poblacionPais: number;
+  countryBirthRate: number;
+  countryPpulation: 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

@@ -8,13 +8,13 @@ import extraData from '../DTOs/ExtraDataDTO';
 
 // eslint-disable-next-line max-len
 const calculateEnergeticRequirement = (groups: AgeGroupJSON[], data: extraData): CalculatorResponse => {
-  const parametros = new Map<number[], AgeGroup>();
+  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, data);
+  const res: CalculatorResponse = ERCalculator.calculateER(parameters, data);
 
   return res;
 };

src/Services/ERCalculator.ts

@@ -3,32 +3,32 @@ import EnergeticRequirement from '../DTOs/EnergeticRequirementDTO';
 import CalculatorResponse from '../DTOs/CalculatorResponseDTO';
 import GroupEnergeticRequirement from '../DTOs/GroupEnergeticRequirementDTO';
 import extraData from '../DTOs/ExtraDataDTO';
-import prevalenciaAFMenores from '../DTOs/MinorPALDTO';
+import MinorPALDTO from '../DTOs/MinorPALDTO';
 import ParserService from './ParserService';
 import AgeBracket from '../Enum/AgeBracket';
 
-const calculateGET = (group: AgeGroup, params: number[], preval: prevalenciaAFMenores): number => {
-  const getModerado: number = params[0]
-  + (params[1] * group.pesoMediano)
-  - params[2] * (group.pesoMediano * group.pesoMediano);
+const calculateGET = (group: AgeGroup, params: number[], preval: MinorPALDTO): number => {
+  const getModerate: number = params[0]
+  + (params[1] * group.medianWeight)
+  - params[2] * (group.medianWeight * group.medianWeight);
 
-  const getLiviano: number = getModerado - (getModerado * params[4]) / 100;
-  const getIntenso: number = getModerado + (getModerado * params[5]) / 100;
+  const getLow: number = getModerate - (getModerate * params[4]) / 100;
+  const getIntense: number = getModerate + (getModerate * params[5]) / 100;
 
-  const ret: number = (getLiviano * preval.NAFLiviano) / 100
-  + (getModerado * preval.NAFModerado) / 100
-  + (getIntenso * preval.NAFIntenso) / 100;
+  const ret: number = (getLow * preval.lowPalPrevalence) / 100
+  + (getModerate * preval.moderatePALPrevalence) / 100
+  + (getIntense * preval.intensePALPrevalence) / 100;
 
   return ret;
 };
 
 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;
@@ -36,14 +36,14 @@ const calculateLessThanAYear = (group: AgeGroup, params: number[]): GroupEnerget
 
 const calculateOneToFiveYears = (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;
@@ -52,18 +52,18 @@ const calculateOneToFiveYears = (group: AgeGroup, params: number[]): GroupEnerge
 // eslint-disable-next-line max-len
 const calculateSixToSeventeenYears = (group: AgeGroup, params: number[], data: extraData): GroupEnergeticRequirement => {
   let get: number;
-  if (typeof (data.prevalenciaAFMenores) === 'undefined') {
+  if (typeof (data.minorPAL) === 'undefined') {
     throw new Error('Data missing');
   } else {
-    get = calculateGET(group, params, data.prevalenciaAFMenores);
+    get = calculateGET(group, params, data.minorPAL);
   }
 
   const requirement = get + 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;
@@ -77,9 +77,9 @@ const calculateER = (groupParameters: Map<number[], AgeGroup>, data: extraData):
   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:
@@ -122,19 +122,19 @@ const calculateER = (groupParameters: Map<number[], AgeGroup>, data: extraData):
         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/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: parseFloat(ageGroup.medianWeight),
+      population: parseFloat(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: String(group.medianWeight),
+    population: String(group.population),
   };
   return retGroup;
 };