Merge remote-tracking branch 'origin/main'

src/main/java/mi/hdm/filesystem/CSVParser.java

@@ -10,6 +10,7 @@ import java.io.BufferedReader;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
+import java.math.BigDecimal;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.InvalidPropertiesFormatException;
@@ -61,7 +62,7 @@ public class CSVParser {
         final List<String> splitLine = splitLine(line, split);
 
         final String recipeName = splitLine.get(idx[0]);
-        final List<Double> nutrition = new ArrayList<>();
+        final List<BigDecimal> nutrition = new ArrayList<>();
 
         for (int i = 1; i < idx.length; i++) {
             //String element = splitLine.get(idx[i]).split(" ")[0];
@@ -70,7 +71,8 @@ public class CSVParser {
             if (getMeasurementFromString(element).equals("mg")) {
                 quantity = quantity /1000;
             }
-            nutrition.add(quantity);
+
+            nutrition.add(BigDecimal.valueOf(quantity));
         }
 
         final NutritionTable nutritionTable = new NutritionTable(nutrition);

src/main/java/mi/hdm/recipes/NutritionCalculator.java

@@ -4,6 +4,7 @@ import mi.hdm.mealPlan.MealPlan;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
+import java.math.BigDecimal;
 import java.time.LocalDate;
 import java.util.Map;
 
@@ -30,7 +31,8 @@ public class NutritionCalculator {
                 totalSalt = 0;
 
         for (RecipeComponent entry : ingredients.keySet()) {
-            final Map<Nutrition, Double> nutritionTable = entry.getNutritionTable().getTable();
+            //TODO: adjust to change in NutritionTable: double -> BigDecimal
+            final Map<Nutrition, BigDecimal> nutritionTable = entry.getNutritionTable().getTable();
 
             int divisor;
             if (entry.getMeasurement() == Measurement.PIECE || entry.getMeasurement() == Measurement.PINCH) {
@@ -38,12 +40,12 @@ public class NutritionCalculator {
             } else {
                 divisor = 100;
             }
-            totalCals += nutritionTable.get(Nutrition.CALORIES) * ingredients.get(entry) / divisor;
-            totalCarbs += nutritionTable.get(Nutrition.CARBS) * ingredients.get(entry) / divisor;
-            totalFats += nutritionTable.get(Nutrition.FAT) * ingredients.get(entry) / divisor;
-            totalProteins += nutritionTable.get(Nutrition.PROTEINS) * ingredients.get(entry) / divisor;
-            totalFibers += nutritionTable.get(Nutrition.FIBERS) * ingredients.get(entry) / divisor;
-            totalSalt += nutritionTable.get(Nutrition.SALT) * ingredients.get(entry) / divisor;
+            totalCals += nutritionTable.get(Nutrition.CALORIES).doubleValue() * ingredients.get(entry) / divisor;
+            totalCarbs += nutritionTable.get(Nutrition.CARBS).doubleValue() * ingredients.get(entry) / divisor;
+            totalFats += nutritionTable.get(Nutrition.FAT).doubleValue() * ingredients.get(entry) / divisor;
+            totalProteins += nutritionTable.get(Nutrition.PROTEINS).doubleValue() * ingredients.get(entry) / divisor;
+            totalFibers += nutritionTable.get(Nutrition.FIBERS).doubleValue() * ingredients.get(entry) / divisor;
+            totalSalt += nutritionTable.get(Nutrition.SALT).doubleValue() * ingredients.get(entry) / divisor;
         }
         log.info("NutritionTable calculated successfully.");
         return new NutritionTable(totalCals, totalCarbs, totalFats, totalProteins, totalFibers, totalSalt);
@@ -62,13 +64,13 @@ public class NutritionCalculator {
                 totalSalt = 0;
 
         for (Recipe r : plan.values()) {
-            final Map<Nutrition, Double> nutritionTable = r.getNutritionTable().getTable();
-            totalCals += nutritionTable.get(Nutrition.CALORIES);
-            totalCarbs += nutritionTable.get(Nutrition.CARBS);
-            totalFats += nutritionTable.get(Nutrition.FAT);
-            totalProteins += nutritionTable.get(Nutrition.PROTEINS);
-            totalFibers += nutritionTable.get(Nutrition.FIBERS);
-            totalSalt += nutritionTable.get(Nutrition.SALT);
+            final Map<Nutrition, BigDecimal> nutritionTable = r.getNutritionTable().getTable();
+            totalCals += nutritionTable.get(Nutrition.CALORIES).doubleValue();
+            totalCarbs += nutritionTable.get(Nutrition.CARBS).doubleValue();
+            totalFats += nutritionTable.get(Nutrition.FAT).doubleValue();
+            totalProteins += nutritionTable.get(Nutrition.PROTEINS).doubleValue();
+            totalFibers += nutritionTable.get(Nutrition.FIBERS).doubleValue();
+            totalSalt += nutritionTable.get(Nutrition.SALT).doubleValue();
         }
         log.info("NutritionTable calculated successfully.");
 

src/main/java/mi/hdm/recipes/NutritionTable.java

@@ -2,20 +2,28 @@ package mi.hdm.recipes;
 
 import mi.hdm.exceptions.InvalidNutritionTableException;
 
+import java.math.BigDecimal;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 public class NutritionTable {
     //TODO: refactor this class to use BigDecimal
-    private final Map<Nutrition, Double> table;
+    private final Map<Nutrition, BigDecimal> table;
 
     /**
      * Creates a new nutrition table that can be used in an ingredient. Expects values for all the nutrition values in order: Calories, Carbs, Fats, Proteins, Fibers, Salt.
      * All values supplied should be in relation to 100 grams or 1 piece.
      */
-    public NutritionTable(double calories, double carbs, double fats, double proteins, double fibers, double salt) {
-        if (calories < 0 || carbs < 0 || fats < 0 || proteins < 0 || fibers < 0 || salt < 0) {
+    public NutritionTable(double caloriesDouble, double carbsDouble, double fatsDouble, double proteinsDouble, double fibersDouble, double saltDouble) {
+
+        BigDecimal calories = BigDecimal.valueOf(caloriesDouble),
+                carbs = BigDecimal.valueOf(carbsDouble),
+                fats = BigDecimal.valueOf(fatsDouble),
+                proteins = BigDecimal.valueOf(proteinsDouble),
+                fibers = BigDecimal.valueOf(fibersDouble),
+                salt = BigDecimal.valueOf(saltDouble);
+        if (calories.compareTo(BigDecimal.ZERO) < 0 || carbs.compareTo(BigDecimal.ZERO) < 0 || fats.compareTo(BigDecimal.ZERO) < 0 || proteins.compareTo(BigDecimal.ZERO) < 0 || fibers.compareTo(BigDecimal.ZERO) < 0 || salt.compareTo(BigDecimal.ZERO) < 0) {
             throw new InvalidNutritionTableException("Can't create NutritionTable where any of the arguments is < 0");
         }
         this.table = new HashMap<>();
@@ -28,7 +36,7 @@ public class NutritionTable {
         table.put(Nutrition.SALT, salt);
     }
 
-    public NutritionTable(List<Double> nutrition) {
+    public NutritionTable(List<BigDecimal> nutrition) {
         if (nutrition == null || nutrition.size() != Nutrition.values().length)
             throw new InvalidNutritionTableException("You supplied a list that was null or had an invalid size.");
 
@@ -42,15 +50,15 @@ public class NutritionTable {
     private NutritionTable() {
         this.table = new HashMap<>();
 
-        table.put(Nutrition.CALORIES, 0.0);
-        table.put(Nutrition.CARBS, 0.0);
-        table.put(Nutrition.FAT, 0.0);
-        table.put(Nutrition.PROTEINS, 0.0);
-        table.put(Nutrition.FIBERS, 0.0);
-        table.put(Nutrition.SALT, 0.0);
+        table.put(Nutrition.CALORIES, BigDecimal.valueOf(0.0));
+        table.put(Nutrition.CARBS, BigDecimal.valueOf(0.0));
+        table.put(Nutrition.FAT, BigDecimal.valueOf(0.0));
+        table.put(Nutrition.PROTEINS, BigDecimal.valueOf(0.0));
+        table.put(Nutrition.FIBERS, BigDecimal.valueOf(0.0));
+        table.put(Nutrition.SALT, BigDecimal.valueOf(0.0));
     }
 
-    public Map<Nutrition, Double> getTable() {
+    public Map<Nutrition, BigDecimal> getTable() {
         return table;
     }
 
@@ -67,14 +75,15 @@ public class NutritionTable {
      */
     @Override
     public boolean equals(Object o) {
+        //TODO: rewrite method
         if (o instanceof NutritionTable n) {
-            double delta = 0.001;
-            return n.getTable().get(Nutrition.CALORIES) - table.get(Nutrition.CALORIES) < delta
-                    && n.getTable().get(Nutrition.CARBS) - table.get(Nutrition.CARBS) < delta
-                    && n.getTable().get(Nutrition.FAT) - table.get(Nutrition.FAT) < delta
-                    && n.getTable().get(Nutrition.PROTEINS) - table.get(Nutrition.PROTEINS) < delta
-                    && n.getTable().get(Nutrition.FIBERS) - table.get(Nutrition.FIBERS) < delta
-                    && n.getTable().get(Nutrition.SALT) - table.get(Nutrition.SALT) < delta;
+
+            return n.getTable().get(Nutrition.CALORIES).equals(table.get(Nutrition.CALORIES))
+                    && n.getTable().get(Nutrition.CARBS).equals(table.get(Nutrition.CARBS))
+                    && n.getTable().get(Nutrition.FAT).equals(table.get(Nutrition.FAT))
+                    && n.getTable().get(Nutrition.PROTEINS).equals(table.get(Nutrition.PROTEINS))
+                    && n.getTable().get(Nutrition.FIBERS).equals(table.get(Nutrition.FIBERS))
+                    && n.getTable().get(Nutrition.SALT).equals(table.get(Nutrition.SALT));
         }
         return false;
     }

src/test/java/mi/hdm/recipes/NutritionTableTest.java

@@ -4,6 +4,7 @@ import mi.hdm.exceptions.InvalidNutritionTableException;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
+import java.math.BigDecimal;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -28,13 +29,13 @@ public class NutritionTableTest {
         NutritionTable underTest = new NutritionTable(calories, carbs, fats, protein, fibers, salt);
 
         //expect
-        Map<Nutrition, Double> expected = new HashMap<>();
-        expected.put(Nutrition.CALORIES, calories);
-        expected.put(Nutrition.CARBS, carbs);
-        expected.put(Nutrition.FAT, fats);
-        expected.put(Nutrition.PROTEINS, protein);
-        expected.put(Nutrition.FIBERS, fibers);
-        expected.put(Nutrition.SALT, salt);
+        Map<Nutrition, BigDecimal> expected = new HashMap<>();
+        expected.put(Nutrition.CALORIES, BigDecimal.valueOf(calories));
+        expected.put(Nutrition.CARBS, BigDecimal.valueOf(carbs));
+        expected.put(Nutrition.FAT, BigDecimal.valueOf(fats));
+        expected.put(Nutrition.PROTEINS, BigDecimal.valueOf(protein));
+        expected.put(Nutrition.FIBERS, BigDecimal.valueOf(fibers));
+        expected.put(Nutrition.SALT, BigDecimal.valueOf(salt));
 
         Assertions.assertEquals(expected, underTest.getTable());
     }