Working prototype for calculating from 0 months to 5 years

ParserService created for parsing and unparsing of AgeGroups, DTOs created (AgeGroupJSON, GroupEnergeticRequisement) , changed DTOs (CalculatorResponseDTO) and enums (AgeBracket, Sex) and fixes to Calculator Service, ERCalculator and ParameterService

src/Controllers/CalculatorController.ts

 import {
   Handler, Request, Response, Router,
 } from 'express';
-import AgeGroup from '../DTOs/AgeGroupDTO';
+import AgeGroupJSON from '../DTOs/AgeGroupJSON';
 import CalculatorService from '../Services/CalculatorService';
 import CalculatorResponse from '../DTOs/CalculatorResponseDTO';
 
 const router = Router();
 
 const getREP: Handler = async (req: Request, res: Response) => {
-  const groups: AgeGroup[] = req.body;
+  const groups: AgeGroupJSON[] = req.body;
   try {
     const EnergyReq: CalculatorResponse = CalculatorService.calculateEnergeticRequirement(groups);
     return res.status(200).send(EnergyReq);

src/Controllers/SheetController.ts

-import {
-  Handler, Request, Response, Router,
-} from 'express';
-import { SheetParserResponse } from '../Models/SheetParserResponse';
-import SheetService from '../Services/SheetService';
-
-const router = Router();
-
-const parseSheet: Handler = async (req: Request, res: Response) => {
-  const sheet: Buffer = req.body;
-  try {
-    const parsedSheet: SheetParserResponse = SheetService.parseSheetService(sheet);
-    return res.status(200).send(parsedSheet);
-  } catch (error) {
-    const e = error as Error;
-    return res.status(400).json({ error: e.message });
-  }
-};
-
-/**
- * @swagger
- * /excelParser:
- *  post:
- *      tags:
- *          -   parser
- *      description: Sheet Parser
- *      requestBody:
- *          required: true
- *          content:
- *              application/json:
- *                  schema:
- *                      type: object
- *                      required:
- *                          -   email
- *                          -   password
- *                      properties:
- *                          excel:
- *                              type: string
- *      responses:
- *          '200':
- *              description: returns the parsed JSON of the excel file provided
- *              content:
- *                  application/json:
- *                      schema:
- *                          type: object
- *                          properties:
- *                              excelParsed:
- *                                  type: string
- */
-router.post('/', parseSheet);
-
-export default router;
+import {
+  Handler, Request, Response, Router,
+} from 'express';
+import { SheetParserResponse } from '../Models/SheetParserResponse';
+import SheetService from '../Services/SheetService';
+
+const router = Router();
+
+const parseSheet: Handler = async (req: Request, res: Response) => {
+  const sheet: Buffer = req.body;
+  try {
+    const parsedSheet: SheetParserResponse = SheetService.parseSheetService(sheet);
+    return res.status(200).send(parsedSheet);
+  } catch (error) {
+    const e = error as Error;
+    return res.status(400).json({ error: e.message });
+  }
+};
+
+/**
+ * @swagger
+ * /excelParser:
+ *  post:
+ *      tags:
+ *          -   parser
+ *      description: Sheet Parser
+ *      requestBody:
+ *          required: true
+ *          content:
+ *              application/json:
+ *                  schema:
+ *                      type: object
+ *                      required:
+ *                          -   email
+ *                          -   password
+ *                      properties:
+ *                          excel:
+ *                              type: string
+ *      responses:
+ *          '200':
+ *              description: returns the parsed JSON of the excel file provided
+ *              content:
+ *                  application/json:
+ *                      schema:
+ *                          type: object
+ *                          properties:
+ *                              excelParsed:
+ *                                  type: string
+ */
+router.post('/', parseSheet);
+
+export default router;

src/DTOs/AgeGroupJSON.ts

+type AgeGroupJSON = {
+  edad: string;
+  sexo: string;
+  pesoMediano: number;
+  cantidad: number;
+};
+
+export default AgeGroupJSON;

src/DTOs/CalculatorResponseDTO.ts

-import AgeGroup from './AgeGroupDTO';
 import EnergeticRequirement from './EnergeticRequirementDTO';
+import GroupEnergeticRequirement from './GroupEnergeticRequirementDTO';
 
 type CalculatorResponse = {
-  requerimientosPorGrupo: Map<AgeGroup, EnergeticRequirement>;
+  requerimientosPorGrupo: GroupEnergeticRequirement[];
   requerimientoTotal: EnergeticRequirement;
 };
 

src/DTOs/GroupEnergeticRequirementDTO.ts

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

src/Enum/AgeBracket.ts

 enum AgeBracket {
-  '0 meses',
-  '1 mes',
-  '2 meses',
-  '3 meses',
-  '4 meses',
-  '5 meses',
-  '6 meses',
-  '7 meses',
-  '8 meses',
-  '9 meses',
-  '10 meses',
-  '11 meses',
-  '1 año',
-  '2 años',
-  '3 años',
-  '4 años',
-  '5 años',
-  '6 años',
-  '7 años',
-  '8 años',
-  '9 años',
-  '10 años',
-  '11 años',
-  '12 años',
-  '13 años',
-  '14 años',
-  '15 años',
-  '16 años',
-  '17 años',
-  '18-29 años',
-  '30-59 años',
-  '60+ años'
+  m0 = '0 meses',
+  m1 = '1 mes',
+  m2 = '2 meses',
+  m3 = '3 meses',
+  m4 = '4 meses',
+  m5 = '5 meses',
+  m6 = '6 meses',
+  m7 = '7 meses',
+  m8 = '8 meses',
+  m9 = '9 meses',
+  m10 = '10 meses',
+  m11 = '11 meses',
+  a1 = '1 año',
+  a2 = '2 años',
+  a3 = '3 años',
+  a4 = '4 años',
+  a5 = '5 años',
+  a6 = '6 años',
+  a7 = '7 años',
+  a8 = '8 años',
+  a9 = '9 años',
+  a10 = '10 años',
+  a11 = '11 años',
+  a12 = '12 años',
+  a13 = '13 años',
+  a14 = '14 años',
+  a15 = '15 años',
+  a16 = '16 años',
+  a17 = '17 años',
+  a18_29 = '18-29 años',
+  a30_59 = '30-59 años',
+  a60 = '60+ años',
 }
 
 export default AgeBracket;

src/Enum/Sex.ts

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

src/Models/SheetParserResponse.ts

-type SheetParserResponse = {
-  hombresMenores: Menores[] | null;
-  mujeresMenores: Menores[] | null;
-  hombres: Mayores[] | null;
-  mujeres: Mayores[] | null;
-} | null;
-
-type Menores = {
-  edad: number;
-  peso: number;
-} | null;
-
-type Mayores = {
-  edad: number;
-  peso?: number;
-  talla?: number;
-} | null;
-
-type MenoresSheet = {
-  'Edad (meses)': number;
-  'Peso (Kg)': number;
-};
-type MayoresSheet = {
-  'Edad (años)': number;
-  'Peso (Kg)': number;
-  'Talla (cm)': number;
-};
-
-export type {
-  SheetParserResponse, Menores, Mayores, MenoresSheet, MayoresSheet,
-};
+type SheetParserResponse = {
+  hombresMenores: Menores[] | null;
+  mujeresMenores: Menores[] | null;
+  hombres: Mayores[] | null;
+  mujeres: Mayores[] | null;
+} | null;
+
+type Menores = {
+  edad: number;
+  peso: number;
+} | null;
+
+type Mayores = {
+  edad: number;
+  peso?: number;
+  talla?: number;
+} | null;
+
+type MenoresSheet = {
+  'Edad (meses)': number;
+  'Peso (Kg)': number;
+};
+type MayoresSheet = {
+  'Edad (años)': number;
+  'Peso (Kg)': number;
+  'Talla (cm)': number;
+};
+
+export type {
+  SheetParserResponse, Menores, Mayores, MenoresSheet, MayoresSheet,
+};

src/Services/CalculatorService.ts

 import ERCalculator from './ERCalculator';
+import ParameterService from './ParameterService';
+import ParserService from './ParserService';
 import AgeGroup from '../DTOs/AgeGroupDTO';
 import CalculatorResponse from '../DTOs/CalculatorResponseDTO';
+import AgeGroupJSON from '../DTOs/AgeGroupJSON';
 
-const calculateEnergeticRequirement = (ageGroups: AgeGroup[]): CalculatorResponse => {
+const calculateEnergeticRequirement = (data: AgeGroupJSON[]): CalculatorResponse => {
   const parametros = new Map<number[], AgeGroup>();
-  const params: number[] = [0, 0, 0];
+  const ageGroups = ParserService.parseGroups(data);
   ageGroups.forEach((group: AgeGroup) => {
-    parametros.set(params, group);
+    parametros.set(ParameterService.getEquationValues(group.edad, group.sexo), group);
   });
+
   const res: CalculatorResponse = ERCalculator.calculateER(parametros);
+
   return res;
 };
 

src/Services/ERCalculator.ts

 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 AgeBracket from '../Enum/AgeBracket';
+
+const calculateLessThanAYear = (group: AgeGroup, params: number[]): GroupEnergeticRequirement => {
+  const requirement = params[0] + (params[1] * group.pesoMediano) + params[2];
+
+  const groupRequirement: GroupEnergeticRequirement = {
+    grupoEtario: ParserService.unparseGroup(group),
+    requerimientoEnergeticoPerCapita: requirement,
+    requerimientoEnergeticoTotal: requirement * group.cantidad,
+  };
+
+  return groupRequirement;
+};
+
+const calculateOneToFiveYears = (group: AgeGroup, params: number[]): GroupEnergeticRequirement => {
+  const requirement = params[0]
+  + (params[1] * group.pesoMediano)
+  + (params[2] * (group.pesoMediano ** 2))
+  + params[3];
+
+  const groupRequirement: GroupEnergeticRequirement = {
+    grupoEtario: ParserService.unparseGroup(group),
+    requerimientoEnergeticoPerCapita: requirement,
+    requerimientoEnergeticoTotal: requirement * group.cantidad,
+  };
+
+  return groupRequirement;
+};
 
 const calculateER = (groupParameters: Map<number[], AgeGroup>): CalculatorResponse => {
   let totalOfPeople = 0;
   let totalRequirement = 0;
 
-  const requirements = new Map();
+  const requirements: GroupEnergeticRequirement[] = [];
 
-  groupParameters.forEach((group: AgeGroup, parameters: number[]) => {
+  groupParameters.forEach((group: AgeGroup, params: number[]) => {
     totalOfPeople += group.cantidad;
-
-    const requirement = parameters[0]
-    + (parameters[1] * group.pesoMediano)
-    + (parameters[2] * (group.pesoMediano ** 2));
-
-    const groupRequirement: EnergeticRequirement = {
-      requerimientoEnergeticoPerCapita: requirement,
-      requerimientoEnergeticoTotal: requirement * group.cantidad,
-    };
-
+    let groupRequirement: GroupEnergeticRequirement;
+    switch (group.edad) {
+      case AgeBracket.m0:
+      case AgeBracket.m1:
+      case AgeBracket.m2:
+      case AgeBracket.m3:
+      case AgeBracket.m4:
+      case AgeBracket.m5:
+      case AgeBracket.m6:
+      case AgeBracket.m7:
+      case AgeBracket.m8:
+      case AgeBracket.m9:
+      case AgeBracket.m10:
+      case AgeBracket.m11: {
+        groupRequirement = calculateLessThanAYear(group, params);
+        break;
+      }
+      case AgeBracket.a1:
+      case AgeBracket.a2:
+      case AgeBracket.a3:
+      case AgeBracket.a4:
+      case AgeBracket.a5: {
+        groupRequirement = calculateOneToFiveYears(group, params);
+        break;
+      }
+      default: {
+        throw new Error('Parsing error, attribute edad does not respect format');
+      }
+    }
     totalRequirement += groupRequirement.requerimientoEnergeticoTotal;
-
-    requirements.set(group, groupRequirement);
+    requirements.push(groupRequirement);
   });
 
   const totalER: EnergeticRequirement = {
     requerimientoEnergeticoPerCapita: totalRequirement / totalOfPeople,
-    requerimientoEnergeticoTotal: totalOfPeople,
+    requerimientoEnergeticoTotal: totalRequirement,
   };
 
   const result: CalculatorResponse = {

src/Services/ParameterService.ts

@@ -5,19 +5,178 @@ import Sex from '../Enum/Sex';
 const getEquationValues = (ageBracket: AgeBracket, sex: Sex): number[] => {
   let res: number[] = [];
   switch (ageBracket) {
-    // Para personas de entre 1 y 5 años
-    case (AgeBracket['1 año'] || AgeBracket['2 años'] || AgeBracket['3 años'] || AgeBracket['4 años'] || AgeBracket['5 años']): {
+    case (AgeBracket.m0): {
       if (sex === Sex.Masculino) {
-        // 310.2 + (63.3*MP) - 0.263*MP^2
-        res = [310.2, 63.3, -0.263];
+        // -152 + (92.8*MP) + 211
+        res = [-152, 92.8, 211];
       } else if (sex === Sex.Femenino) {
-        // 263.4 + (65.3*MP) - 0.454*MP^2
-        res = [263.4, 65.3, -0.454];
+        // -152 + (92.8*MP) + 178
+        res = [-152, 92.8, 178];
+      }
+      break;
+    }
+    case (AgeBracket.m1): {
+      if (sex === Sex.Masculino) {
+        // -152 + (92.8*MP) + 183
+        res = [-152, 92.8, 183];
+      } else if (sex === Sex.Femenino) {
+        // -152 + (92.8*MP) + 161
+        res = [-152, 92.8, 161];
+      }
+      break;
+    }
+    case (AgeBracket.m2): {
+      if (sex === Sex.Masculino) {
+        // -152 + (92.8*MP) + 139
+        res = [-152, 92.8, 139];
+      } else if (sex === Sex.Femenino) {
+        // -152 + (92.8*MP) + 134
+        res = [-152, 92.8, 134];
+      }
+      break;
+    }
+    case (AgeBracket.m3): {
+      if (sex === Sex.Masculino) {
+        // -152 + (92.8*MP) + 53
+        res = [-152, 92.8, 53];
+      } else if (sex === Sex.Femenino) {
+        // -152 + (92.8*MP) + 68
+        res = [-152, 92.8, 68];
+      }
+      break;
+    }
+    case (AgeBracket.m4): {
+      if (sex === Sex.Masculino) {
+        // -152 + (92.8*MP) + 46
+        res = [-152, 92.8, 46];
+      } else if (sex === Sex.Femenino) {
+        // -152 + (92.8*MP) + 57
+        res = [-152, 92.8, 57];
+      }
+      break;
+    }
+    case (AgeBracket.m5): {
+      if (sex === Sex.Masculino) {
+        // -152 + (92.8*MP) + 36
+        res = [-152, 92.8, 36];
+      } else if (sex === Sex.Femenino) {
+        // -152 + (92.8*MP) + 47
+        res = [-152, 92.8, 47];
+      }
+      break;
+    }
+    case (AgeBracket.m6): {
+      if (sex === Sex.Masculino) {
+        // -99.4 + (88.6*MP) + 17
+        res = [-99.4, 88.6, 17];
+      } else if (sex === Sex.Femenino) {
+        // -99.4 + (88.6*MP) + 20
+        res = [-99.4, 88.6, 20];
+      }
+      break;
+    }
+    case (AgeBracket.m7): {
+      if (sex === Sex.Masculino) {
+        // -99.4 + (88.6*MP) + 16
+        res = [-99.4, 88.6, 16];
+      } else if (sex === Sex.Femenino) {
+        // -99.4 + (88.6*MP) + 17
+        res = [-99.4, 88.6, 17];
+      }
+      break;
+    }
+    case (AgeBracket.m8): {
+      if (sex === Sex.Masculino) {
+        // -99.4 + (88.6*MP) + 14
+        res = [-99.4, 88.6, 14];
+      } else if (sex === Sex.Femenino) {
+        // -99.4 + (88.6*MP) + 15
+        res = [-99.4, 88.6, 15];
+      }
+      break;
+    }
+    case (AgeBracket.m9): {
+      if (sex === Sex.Masculino) {
+        // -99.4 + (88.6*MP) + 21
+        res = [-99.4, 88.6, 21];
+      } else if (sex === Sex.Femenino) {
+        // -99.4 + (88.6*MP) + 18
+        res = [-99.4, 88.6, 18];
+      }
+      break;
+    }
+    case (AgeBracket.m10): {
+      if (sex === Sex.Masculino) {
+        // -99.4 + (88.6*MP) + 21
+        res = [-99.4, 88.6, 21];
+      } else if (sex === Sex.Femenino) {
+        // -99.4 + (88.6*MP) + 15
+        res = [-99.4, 88.6, 15];
+      }
+      break;
+    }
+    case (AgeBracket.m11): {
+      if (sex === Sex.Masculino) {
+        // -99.4 + (88.6*MP) + 22
+        res = [-99.4, 88.6, 22];
+      } else if (sex === Sex.Femenino) {
+        // -99.4 + (88.6*MP) + 14
+        res = [-99.4, 88.6, 14];
+      }
+      break;
+    }
+    case (AgeBracket.a1): {
+      if (sex === Sex.Masculino) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 13
+        res = [310.2, 63.3, -0.263, 13];
+      } else if (sex === Sex.Femenino) {
+        // 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) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 12
+        res = [310.2, 63.3, -0.263, 12];
+      } else if (sex === Sex.Femenino) {
+        // 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) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 12
+        res = [310.2, 63.3, -0.263, 12];
+      } else if (sex === Sex.Femenino) {
+        // 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) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 11
+        res = [310.2, 63.3, -0.263, 11];
+      } else if (sex === Sex.Femenino) {
+        // 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) {
+        // 310.2 + (63.3*MP) - 0.263*MP^2 + 11
+        res = [310.2, 63.3, -0.263, 11];
+      } else if (sex === Sex.Femenino) {
+        // 263.4 + (65.3*MP) - 0.454*MP^2 + 10
+        res = [263.4, 65.3, -0.454, 10];
       }
       break;
     }
     default: {
-      res = [];
+      throw new Error('Parsing error, attribute edad does not respect format');
     }
   }
   return res;

src/Services/ParserService.ts

+import AgeGroup from '../DTOs/AgeGroupDTO';
+import AgeGroupJSON from '../DTOs/AgeGroupJSON';
+import AgeBracket from '../Enum/AgeBracket';
+import Sex from '../Enum/Sex';
+
+// const parseSex = (sexo: string): Sex => {
+//   let sex: Sex = sexo;
+//   switch (sexo) {
+//     case 'Masculino': {
+//       sex = Sex.Masculino;
+//       break;
+//     }
+//     case 'Femenino': {
+//       sex = Sex.Femenino;
+//       break;
+//     }
+//     default: {
+//       throw new Error('Parsing error, attribute sexo does not respect format');
+//     }
+//   }
+//   return sex;
+// };
+//
+// const parseAge = (edad: string): AgeBracket => {
+//   let age: AgeBracket;
+//   switch (edad) {
+//     case '0 meses': {
+//       age = AgeBracket.m0;
+//       break;
+//     }
+//     case '1 mes': {
+//       age = AgeBracket.m1;
+//       break;
+//     }
+//     case '2 meses': {
+//       age = AgeBracket.m2;
+//       break;
+//     }
+//     case '3 meses': {
+//       age = AgeBracket.m3;
+//       break;
+//     }
+//     case '4 meses': {
+//       age = AgeBracket.m4;
+//       break;
+//     }
+//     case '5 meses': {
+//       age = AgeBracket.m5;
+//       break;
+//     }
+//     case '6 meses': {
+//       age = AgeBracket.m6;
+//       break;
+//     }
+//     case '7 meses': {
+//       age = AgeBracket.m7;
+//       break;
+//     }
+//     case '8 meses': {
+//       age = AgeBracket.m8;
+//       break;
+//     }
+//     case '9 meses': {
+//       age = AgeBracket.m9;
+//       break;
+//     }
+//     case '10 meses': {
+//       age = AgeBracket.m10;
+//       break;
+//     }
+//     case '11 meses': {
+//       age = AgeBracket.m11;
+//       break;
+//     }
+//     case '1 año': {
+//       age = AgeBracket.a1;
+//       break;
+//     }
+//     case '2 años': {
+//       age = AgeBracket.a2;
+//       break;
+//     }
+//     case '3 años': {
+//       age = AgeBracket.a3;
+//       break;
+//     }
+//     case '4 años': {
+//       age = AgeBracket.a4;
+//       break;
+//     }
+//     case '5 años': {
+//       age = AgeBracket.a5;
+//       break;
+//     }
+//     case '6 años': {
+//       age = AgeBracket.a6;
+//       break;
+//     }
+//     case '7 años': {
+//       age = AgeBracket.a7;
+//       break;
+//     }
+//     case '8 años': {
+//       age = AgeBracket.a8;
+//       break;
+//     }
+//     case '9 años': {
+//       age = AgeBracket.a9;
+//       break;
+//     }
+//     case '10 años': {
+//       age = AgeBracket.a10;
+//       break;
+//     }
+//     case '11 años': {
+//       age = AgeBracket.a11;
+//       break;
+//     }
+//     case '12 años': {
+//       age = AgeBracket.a12;
+//       break;
+//     }
+//     case '13 años': {
+//       age = AgeBracket.a13;
+//       break;
+//     }
+//     case '14 años': {
+//       age = AgeBracket.a14;
+//       break;
+//     }
+//     case '15 años': {
+//       age = AgeBracket.a15;
+//       break;
+//     }
+//     case '16 años': {
+//       age = AgeBracket.a16;
+//       break;
+//     }
+//     case '17 años': {
+//       age = AgeBracket.a17;
+//       break;
+//     }
+//     case '18-29 años': {
+//       age = AgeBracket.a18_29;
+//       break;
+//     }
+//     case '30-59 años': {
+//       age = AgeBracket.a30_59;
+//       break;
+//     }
+//     case '60+ años': {
+//       age = AgeBracket.a60;
+//       break;
+//     }
+//     default: {
+//       throw new Error('Parsing error, attribute edad does not respect format');
+//     }
+//   }
+//   return age;
+// };
+
+const parseGroups = (groups: AgeGroupJSON[]): AgeGroup[] => {
+  const retGroups: AgeGroup[] = [];
+  groups.forEach((obj: AgeGroupJSON) => {
+    if (typeof (obj.pesoMediano) !== 'number' || typeof (obj.cantidad) !== 'number') {
+      throw new Error('Parsing error, attributes do not respect format');
+    }
+    const group: AgeGroup = {
+      edad: obj.edad as AgeBracket,
+      sexo: obj.sexo as Sex,
+      pesoMediano: obj.pesoMediano,
+      cantidad: obj.cantidad,
+    };
+    retGroups.push(group);
+  });
+  return retGroups;
+};
+
+const unparseGroup = (group: AgeGroup): AgeGroupJSON => {
+  const retGroup: AgeGroupJSON = {
+    edad: group.edad as string,
+    sexo: group.sexo as string,
+    pesoMediano: group.pesoMediano,
+    cantidad: group.cantidad,
+  };
+  return retGroup;
+};
+
+export default { parseGroups, unparseGroup };