NOJIRA made itemBuilder into service

src/item_builder.py

@@ -1,49 +0,0 @@
-from typing import List, Dict
-
-import Levenshtein
-
-from models.item import Item
-from models.order import Order
-
-
-class ItemBuilder:
-    def __init__(self, orders: List[Order]):
-        self.__item_names: List[str] = _flatten([o.items for o in orders])
-
-    def _translate_part(self, old: str, new: str) -> None:
-        self.__item_names = [i.replace(old, new) for i in self.__item_names]
-
-    def _translate_whole(self, old: str, new: str) -> None:
-        self.__item_names = [new if i == old else i for i in self.__item_names]
-
-    def _consolidate_names(self) -> None:
-        uq_item_names: List[str] = list(set(self.__item_names))
-        print(uq_item_names)
-        for idx, lhs in enumerate(uq_item_names):
-            for rhs in uq_item_names[idx + 1:]:
-                if lhs[0:2] == rhs[0:2]:
-                    distance = Levenshtein.distance(lhs, rhs)
-                    if distance <= 2:
-                        print(lhs + ":" + rhs + " = " + str(distance))
-                        self._translate_whole(lhs, rhs)
-
-    def _aggregate_names(self) -> List[Item]:
-        items: Dict[str, int] = {}
-        for item_name in self.__item_names:
-            if item_name not in items:
-                items[item_name] = 0
-            items[item_name] += 1
-        return sorted([Item(n, a) for n, a in items.items()])
-
-    def build(self) -> List[Item]:
-        self._translate_part("frietje", "friet")
-        self._translate_part("krul friet", "twister")
-        self._translate_part("krulfriet", "twister")
-
-        self._consolidate_names()
-
-        return self._aggregate_names()
-
-
-def _flatten(t: List[List]) -> List:
-    return [item for sublist in t for item in sublist]

src/item_service.py

@@ -0,0 +1,53 @@
+from typing import List, Dict
+
+import Levenshtein
+
+from models.item import Item
+from models.order import Order
+
+
+class ItemService:
+    @staticmethod
+    def _translate_part(item_names: List[str], old: str, new: str) -> List[str]:
+        return [i.replace(old, new) for i in item_names]
+
+    @staticmethod
+    def _translate_whole(item_names: List[str], old: str, new: str) -> List[str]:
+        return [new if i == old else i for i in item_names]
+
+    @staticmethod
+    def _consolidate_names(item_names: List[str]) -> List[str]:
+        uq_item_names: List[str] = list(set(item_names))
+        print(uq_item_names)
+        for idx, lhs in enumerate(uq_item_names):
+            for rhs in uq_item_names[idx + 1:]:
+                if lhs[0:2] == rhs[0:2]:
+                    distance = Levenshtein.distance(lhs, rhs)
+                    if distance <= 2:
+                        print(lhs + ":" + rhs + " = " + str(distance))
+                        ItemService._translate_whole(item_names, lhs, rhs)
+        return item_names
+
+    @staticmethod
+    def _aggregate_items(item_names: List[str]) -> List[Item]:
+        items: Dict[str, int] = {}
+        for item_name in item_names:
+            if item_name not in items:
+                items[item_name] = 0
+            items[item_name] += 1
+        return sorted([Item(n, a) for n, a in items.items()])
+
+    @staticmethod
+    def get_items_from_orders(orders: List[Order]):
+        item_names: List[str] = _flatten([o.items for o in orders])
+        item_names = ItemService._translate_part(item_names, "frietje", "friet")
+        item_names = ItemService._translate_part(item_names, "krul friet", "twister")
+        item_names = ItemService._translate_part(item_names, "krulfriet", "twister")
+
+        item_names = ItemService._consolidate_names(item_names)
+
+        return sorted(ItemService._aggregate_items(item_names))
+
+
+def _flatten(t: List[List]) -> List:
+    return [item for sublist in t for item in sublist]

src/main.py

@@ -2,22 +2,23 @@ from datetime import datetime, timedelta
 
 from flask import render_template
 
-from item_builder import ItemBuilder
+from item_service import ItemService
 from order_repository import OrderRepository
 
 
 def process(_) -> str:
-    min_datetime = datetime.now() - timedelta(days=2)
+    min_datetime = datetime.now() - timedelta(days=200)
     orders = _repository.find_by_datetime_placed_greater_than(min_datetime)
 
-    items = ItemBuilder(orders).build()
+    items = ItemService.get_items_from_orders(orders)
     item_count = sum([len(o.items) for o in orders])
-    applicants = sorted([o.name for o in orders])
+    applicants = [o.name for o in orders]
 
     return render_template('frietlijst.html',
+                           applicants=applicants,
                            items=items,
                            item_count=item_count,
-                           applicants=applicants,
+                           orders=orders,
                            )