printer-core 0.0.1__py3-none-any.whl

printer_core/services/multi_printer_family_service.py

@@ -0,0 +1,102 @@
+from typing import Any, Callable
+
+from printer_core.algorithms.products_modifiers_multiprinter_family import (
+    ProductsModifiersMultiprinterFamily,
+)
+from printer_core.builders.printer_products_grouper import PrinterProductsGrouper
+from printer_core.dispatchers.kitchen_ticket_dispatcher import KitchenTicketDispatcher
+from printer_core.entities import (
+    KitchenProductLine,
+    KitchenTicketPayload,
+    PrintProductData,
+    PrintRequestData,
+    PrinterData,
+    ProductsGroup,
+)
+from printer_core.formatters.discount_formatter import DiscountFormatter
+from printer_core.ports import FamilyCategoryProvider, PrinterGateway
+from printer_core.selectors.family_product_selector import FamilyProductSelector
+from printer_core.utils.printer_helpers import group_products_by_orders, order_products_by_name
+
+
+class MultiPrinterFamilyService:
+    def __init__(
+        self,
+        gateway: PrinterGateway,
+        family_provider: FamilyCategoryProvider,
+        currency_symbol_resolver: Callable[[str], str],
+        order_by_func: Callable[[list[KitchenProductLine]], list[KitchenProductLine]] | None = None,
+        group_products_func: Callable[[list[KitchenProductLine]], list[ProductsGroup]] | None = None,
+    ):
+        self._gateway = gateway
+        self._family_provider = family_provider
+        self._currency_symbol_resolver = currency_symbol_resolver
+        self._order_by_func = order_by_func or order_products_by_name
+        self._group_products_func = group_products_func or group_products_by_orders
+
+    def build_and_dispatch(
+        self,
+        request: PrintRequestData,
+        products: list[PrintProductData],
+        main_printer: PrinterData,
+        ticket_settings: Any,
+        kitchen_ticket_settings: Any,
+    ) -> list[KitchenTicketPayload]:
+        selector = FamilyProductSelector(provider=self._family_provider)
+        families, products_by_family, products_without_family = selector.group_products(products)
+
+        formatter = DiscountFormatter(currency_symbol_resolver=self._currency_symbol_resolver)
+        family_builder = ProductsModifiersMultiprinterFamily(formatter)
+        list_products_own_printer: list[KitchenProductLine] = []
+        dispatched: list[KitchenTicketPayload] = []
+
+        for family in families:
+            list_products_own_printer.clear()
+            family_products = products_by_family.get(family.id, [])
+            for product in family_products:
+                if product.printer:
+                    product_with_printer = product
+                else:
+                    product_with_printer = product.model_copy(update={"printer": [main_printer]})
+                family_builder.append_product(
+                    list_products_own_printer, product_with_printer, request, kitchen_ticket_settings
+                )
+            dispatched.extend(self._dispatch_products(
+                list_products_own_printer, request, ticket_settings, kitchen_ticket_settings
+            ))
+
+        list_products_own_printer.clear()
+        for product in products_without_family:
+            if product.printer:
+                product_with_printer = product
+            else:
+                product_with_printer = product.model_copy(update={"printer": [main_printer]})
+            family_builder.append_product(
+                list_products_own_printer, product_with_printer, request, kitchen_ticket_settings
+            )
+
+        dispatched.extend(self._dispatch_products(
+            list_products_own_printer, request, ticket_settings, kitchen_ticket_settings
+        ))
+        return dispatched
+
+    def _dispatch_products(
+        self,
+        list_products_own_printer: list[KitchenProductLine],
+        request: PrintRequestData,
+        ticket_settings: Any,
+        kitchen_ticket_settings: Any,
+    ) -> list[KitchenTicketPayload]:
+        if not list_products_own_printer:
+            return []
+        if (request.order_by or "standard") == "name":
+            list_products_own_printer = self._order_by_func(list_products_own_printer)
+        grouped_products = PrinterProductsGrouper.group_by_printer_key(list_products_own_printer)
+        dispatcher = KitchenTicketDispatcher(gateway=self._gateway)
+        return dispatcher.dispatch(
+            request=request,
+            grouped_products=grouped_products,
+            ticket_settings=ticket_settings,
+            kitchen_ticket_settings=kitchen_ticket_settings,
+            group_products_func=self._group_products_func,
+        )

printer_core/services/multi_printer_service.py

@@ -0,0 +1,49 @@
+from typing import Any, Callable
+
+from printer_core.algorithms.products_modifiers_multiprinter import ProductsModifiersMultiPrinter
+from printer_core.builders.printer_products_grouper import PrinterProductsGrouper
+from printer_core.dispatchers.kitchen_ticket_dispatcher import KitchenTicketDispatcher
+from printer_core.entities import KitchenProductLine, KitchenTicketPayload, PrintProductData, PrintRequestData, PrinterData, ProductsGroup
+from printer_core.formatters.discount_formatter import DiscountFormatter
+from printer_core.ports import PrinterGateway
+from printer_core.utils.printer_helpers import group_products_by_orders, order_products_by_name
+
+
+class MultiPrinterService:
+    def __init__(
+        self,
+        gateway: PrinterGateway,
+        currency_symbol_resolver: Callable[[str], str],
+        order_by_func: Callable[[list[KitchenProductLine]], list[KitchenProductLine]] | None = None,
+        group_products_func: Callable[[list[KitchenProductLine]], list[ProductsGroup]] | None = None,
+    ):
+        self._gateway = gateway
+        self._currency_symbol_resolver = currency_symbol_resolver
+        self._order_by_func = order_by_func or order_products_by_name
+        self._group_products_func = group_products_func or group_products_by_orders
+
+    def build_and_dispatch(
+        self,
+        request: PrintRequestData,
+        products: list[PrintProductData],
+        main_printer: PrinterData,
+        ticket_settings: Any,
+        kitchen_ticket_settings: Any,
+    ) -> list[KitchenTicketPayload]:
+        formatter = DiscountFormatter(currency_symbol_resolver=self._currency_symbol_resolver)
+        list_products_own_printer = ProductsModifiersMultiPrinter(formatter).build(
+            request, products, kitchen_ticket_settings, main_printer
+        )
+
+        if (request.order_by or "standard") == "name":
+            list_products_own_printer = self._order_by_func(list_products_own_printer)
+
+        grouped_products = PrinterProductsGrouper.group_by_printer_key(list_products_own_printer)
+        dispatcher = KitchenTicketDispatcher(gateway=self._gateway)
+        return dispatcher.dispatch(
+            request=request,
+            grouped_products=grouped_products,
+            ticket_settings=ticket_settings,
+            kitchen_ticket_settings=kitchen_ticket_settings,
+            group_products_func=self._group_products_func,
+        )

printer_core/services/order_print_service.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Any, Callable
+
+from printer_core.clock import SystemClock
+from printer_core.entities import (
+    PrintChannel,
+    PrintJob,
+    PrintRequestData,
+    PrintResult,
+)
+from printer_core.services.flows import PrintFlow
+from printer_core.services.print_policy import FlowTarget, PrintPolicy
+from printer_core.utils.printer_helpers import build_iva_data
+from printer_core.ports import FamilyCategoryProvider, HeaderProvider, PrinterGateway, PrintSettingsBuilder
+
+
+class OrderPrintService:
+    def __init__(
+        self,
+        gateway: PrinterGateway,
+        header_provider: HeaderProvider,
+        print_settings_builder: PrintSettingsBuilder,
+        family_provider: FamilyCategoryProvider,
+        currency_symbol_resolver: Callable[[str], str],
+        flows: list[PrintFlow],
+        domicile_service_label: str = "Domicile Service",
+    ):
+        self._gateway = gateway
+        self._family_provider = family_provider
+        self._currency_symbol_resolver = currency_symbol_resolver
+        self._header_provider = header_provider
+        self._print_settings_builder = print_settings_builder
+        self._domicile_service_label = domicile_service_label
+        self._clock = SystemClock()
+        self._flows = flows
+
+    def print_job(self, job: PrintJob, context: Any, channel: PrintChannel) -> PrintResult:
+        base_request = self._build_request(job.request, context, channel)
+        products = job.products
+
+        result = PrintResult()
+        policy = PrintPolicy(channel, context.ticket_settings, context.global_settings)
+        plan = policy.plan(base_request)
+
+        for flow in self._flows:
+            if flow.target not in plan.enabled_flows:
+                continue
+            data = flow.execute(
+                base_request=base_request,
+                products=products,
+                context=context,
+                channel=channel,
+                tpv_key=job.tpv_key,
+            )
+            if flow.target == FlowTarget.KITCHEN:
+                result = result.model_copy(update={"multi_printer": data})
+            elif flow.target == FlowTarget.CLIENT:
+                result = result.model_copy(update={"ticket_client": data})
+
+        return result
+
+    def _build_request(
+        self,
+        request: PrintRequestData,
+        context: Any,
+        channel: PrintChannel,
+    ) -> PrintRequestData:
+        enriched = self._normalize_discount(channel, request)
+        if not enriched.print_by and getattr(context.kitchen_settings, "print_by", None):
+            enriched = enriched.model_copy(update={"print_by": context.kitchen_settings.print_by})
+        if channel in (PrintChannel.KIOSKO, PrintChannel.BARRA):
+            enriched = enriched.model_copy(update={"created_at": self._clock.now_iso()})
+        if not enriched.currency and getattr(context.global_settings, "currency", None):
+            enriched = enriched.model_copy(update={"currency": context.global_settings.currency})
+
+        total, enriched = self._compute_total(channel, enriched)
+        iva_data = build_iva_data(total, Decimal(str(context.global_settings.iva)))
+        enriched = enriched.model_copy(update={"total": str(total), "ivaData": iva_data})
+        return enriched
+
+    def _compute_total(self, channel: PrintChannel, request: PrintRequestData) -> tuple[Decimal, PrintRequestData]:
+        request_price = Decimal(str(request.request_price)).quantize(Decimal(".01"))
+        if channel != PrintChannel.DOMICILE:
+            if request.price_domicile_service is not None:
+                request = request.model_copy(update={"price_domicile_service": None})
+            return request_price, request
+        domicile_price = Decimal(str(request.price_domicile_service or "0")).quantize(Decimal(".01"))
+        request = request.model_copy(update={"price_domicile_service": str(domicile_price)})
+        return request_price + domicile_price, request
+
+    def _normalize_discount(self, channel: PrintChannel, request: PrintRequestData) -> PrintRequestData:
+        if channel == PrintChannel.LOCAL:
+            return request.model_copy(update={"discount": None})
+        if channel in (PrintChannel.KIOSKO, PrintChannel.BARRA) and not request.all_discounted:
+            return request.model_copy(update={"discount": None})
+        return request

printer_core/services/print_policy.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+from printer_core.entities import PrintChannel, PrintRequestData
+
+
+class FlowTarget(str, Enum):
+    KITCHEN = "kitchen"
+    CLIENT = "client"
+
+
+@dataclass(frozen=True)
+class PrintPlan:
+    enabled_flows: set[FlowTarget] = field(default_factory=set)
+    reasons: list[str] = field(default_factory=list)
+
+    @property
+    def print_kitchen(self) -> bool:
+        return FlowTarget.KITCHEN in self.enabled_flows
+
+    @property
+    def print_client(self) -> bool:
+        return FlowTarget.CLIENT in self.enabled_flows
+
+
+class PrintPolicy:
+    def __init__(self, channel: PrintChannel, ticket_settings: Any, global_settings: Any):
+        self._channel = channel
+        self._ticket_settings = ticket_settings
+        self._global_settings = global_settings
+
+    def plan(self, request: PrintRequestData) -> PrintPlan:
+        print_kitchen = self._should_print_kitchen()
+        print_client = self._should_print_client(request)
+        enabled_flows: set[FlowTarget] = set()
+        if print_kitchen:
+            enabled_flows.add(FlowTarget.KITCHEN)
+        if print_client:
+            enabled_flows.add(FlowTarget.CLIENT)
+        return PrintPlan(enabled_flows=enabled_flows)
+
+    def _should_print_kitchen(self) -> bool:
+        if self._channel in (PrintChannel.KIOSKO, PrintChannel.BARRA):
+            return bool(getattr(self._ticket_settings, "ticket_kitchen_barra", False))
+        if self._channel == PrintChannel.LOCAL:
+            return bool(getattr(self._ticket_settings, "ticket_kitchen_local", False))
+        return bool(getattr(self._ticket_settings, "ticket_kitchen_domicile_or_pickup", False))
+
+    def _should_print_client(self, request: PrintRequestData) -> bool:
+        if self._channel in (PrintChannel.KIOSKO, PrintChannel.BARRA):
+            enabled = bool(getattr(self._ticket_settings, "ticket_client_barra", False))
+            if not enabled:
+                return False
+            if self._channel == PrintChannel.BARRA and self._barra_payment_suppresses(request):
+                return False
+            return True
+        if self._channel == PrintChannel.LOCAL:
+            return bool(getattr(self._ticket_settings, "ticket_client_local", False))
+        return bool(getattr(self._ticket_settings, "ticket_client_domicile_or_pickup", False))
+
+    def _barra_payment_suppresses(self, request: PrintRequestData) -> bool:
+        credit_card = bool(request.credit_card)
+        if getattr(self._global_settings, "use_payment_terminal", False) and credit_card:
+            return True
+        if getattr(self._global_settings, "use_cashmatic", False) and not credit_card:
+            return True
+        if getattr(self._global_settings, "use_cashlogy", False) and not credit_card:
+            return True
+        return False

printer_core/services/unique_ticket_service.py

@@ -0,0 +1,52 @@
+from typing import Any, Callable
+
+from printer_core.algorithms.products_modifiers_unique_ticket import ProductsModifiersUniqueTicket
+from printer_core.entities import ClientTicketData, ClientTicketPayload, PrintProductData, PrintRequestData, PrinterData
+from printer_core.formatters.discount_formatter import DiscountFormatter
+
+
+class UniqueTicketService:
+    def __init__(
+        self,
+        currency_symbol_resolver: Callable[[str], str],
+        domicile_service_label: str,
+    ):
+        self._currency_symbol_resolver = currency_symbol_resolver
+        self._domicile_service_label = domicile_service_label
+
+    def build_payload(
+        self,
+        request: PrintRequestData,
+        products: list[PrintProductData],
+        ticket_settings: Any,
+        printer: PrinterData,
+        tpv_key: str,
+    ) -> list[ClientTicketPayload]:
+        formatter = DiscountFormatter(currency_symbol_resolver=self._currency_symbol_resolver)
+        list_products_in_same_printers = ProductsModifiersUniqueTicket(
+            formatter, domicile_service_label=self._domicile_service_label
+        ).build(request, products)
+
+        ticket_text = getattr(ticket_settings, "ticket_text", "")
+        qty_client_ticket = getattr(ticket_settings, "qty_client_ticket", 1)
+
+        client_request = ClientTicketData(
+            **request.model_dump(exclude={"products", "ticket_text"}),
+            ticket_text=ticket_text,
+            products=list_products_in_same_printers,
+        )
+        if client_request.type in ["domicilio", "recoger"]:
+            client_request = client_request.model_copy(update={"details": client_request.details or ""})
+        elif client_request.details:
+            client_request = client_request.model_copy(update={"details": None})
+
+        payload = ClientTicketPayload(
+            data=client_request,
+            currency=client_request.currency or "",
+            model=2,
+            company_key=tpv_key,
+            printer=printer.name,
+            printer_qty=qty_client_ticket,
+            printer_width=printer.printer_width,
+        )
+        return [payload]

printer_core/tests/unitaries/helpers.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+from printer_core.entities import (
+    DiscountData,
+    FamilyData,
+    HeaderData,
+    PrintProductData,
+    PrintRequestData,
+    PrintSettingsData,
+    PrinterData,
+)
+
+
+class FakeGateway:
+    def __init__(self):
+        self.calls: list[tuple[str, object]] = []
+
+    def send_data(self, tpv_key: str, data: object) -> None:
+        self.calls.append((tpv_key, data))
+
+
+class FakeClock:
+    def __init__(self, now_value: str = "2024-01-01 10:00"):
+        self._now_value = now_value
+
+    def now_iso(self) -> str:
+        return self._now_value
+
+
+class FakeHeaderProvider:
+    def build_header(self, request: PrintRequestData, worker: object | None = None) -> HeaderData:
+        worker_name = getattr(worker, "first_name", None) if worker else None
+        return HeaderData(
+            company_name="Company",
+            worker_name=worker_name,
+            client_name=f"{request.type}:{request.from_client}",
+        )
+
+
+class FakePrintSettingsBuilder:
+    def __init__(self, settings: PrintSettingsData | None = None):
+        self._settings = settings or PrintSettingsData(
+            show_header=True,
+            show_total_price=True,
+            show_price_per_unit=False,
+            show_local_header=None,
+            details_font={"size": 10},
+        )
+
+    def build(self, kitchen_ticket_settings: object) -> PrintSettingsData:
+        return self._settings
+
+
+class FakeFamilyProvider:
+    def __init__(self, families: list[FamilyData], family_by_category: dict[int, FamilyData]):
+        self._families = families
+        self._family_by_category = family_by_category
+
+    def get_families(self) -> list[FamilyData]:
+        return self._families
+
+    def get_family_by_category_ids(self, category_ids: list[int]) -> dict[int, FamilyData]:
+        return {cid: self._family_by_category[cid] for cid in category_ids if cid in self._family_by_category}
+
+
+def make_discount(value: str = "10", discount_type: str = "percent", total: str = "0") -> DiscountData:
+    return DiscountData(value=value, type=discount_type, total=total)
+
+
+def make_request(
+    request_type: str = "local",
+    from_client: str = "web",
+    credit_card: bool = False,
+    request_price: str = "10.00",
+    currency: str | None = "EUR",
+    all_discounted: bool = False,
+    discount: DiscountData | None = None,
+    price_domicile_service: str | None = None,
+    **overrides: object,
+) -> PrintRequestData:
+    payload = {
+        "id": 1,
+        "type": request_type,
+        "serial": "S1",
+        "credit_card": credit_card,
+        "request_price": request_price,
+        "from_client": from_client,
+        "currency": currency,
+        "all_discounted": all_discounted,
+        "discount": discount,
+        "price_domicile_service": price_domicile_service,
+        "command_guests": 2,
+        "table_name": "T1",
+    }
+    payload.update(overrides)
+    return PrintRequestData(**payload)
+
+
+def make_product(
+    name: str = "Burger",
+    qty: int = 1,
+    total_price: str = "5.00",
+    product_price: str = "5.00",
+    **overrides: object,
+) -> PrintProductData:
+    payload = {
+        "product_name": name,
+        "qty": qty,
+        "total_price": total_price,
+        "product_price": product_price,
+    }
+    payload.update(overrides)
+    return PrintProductData(**payload)
+
+
+def make_printer(name: str = "P1", printer_width: str = "80", tpv: str | None = "TPV1") -> PrinterData:
+    return PrinterData(name=name, printer_width=printer_width, tpv=tpv)
+
+
+def make_print_settings(
+    show_header: bool | None = True,
+    show_total_price: bool | None = True,
+    show_price_per_unit: bool | None = False,
+    show_local_header: bool | None = None,
+    details_font: dict[str, object] | str | None = None,
+) -> PrintSettingsData:
+    return PrintSettingsData(
+        show_header=show_header,
+        show_total_price=show_total_price,
+        show_price_per_unit=show_price_per_unit,
+        show_local_header=show_local_header,
+        details_font=details_font,
+    )
+
+
+def make_ticket_settings(
+    order_by: str | None = None,
+    qty_kitchen_ticket: int = 1,
+    qty_client_ticket: int = 1,
+    ticket_text: str = "",
+    **overrides: object,
+) -> SimpleNamespace:
+    payload = {
+        "order_by": order_by,
+        "qty_kitchen_ticket": qty_kitchen_ticket,
+        "qty_client_ticket": qty_client_ticket,
+        "ticket_text": ticket_text,
+    }
+    payload.update(overrides)
+    return SimpleNamespace(**payload)
+
+
+def make_kitchen_settings(
+    group_by_orders: bool = False,
+    print_by: str = "categories",
+    show_total_price: bool = False,
+    show_command_guests: bool = False,
+    show_price_per_unit: bool = False,
+    show_local_header: bool = True,
+    show_domicile_header: bool = True,
+) -> SimpleNamespace:
+    return SimpleNamespace(
+        group_by_orders=group_by_orders,
+        print_by=print_by,
+        show_total_price=show_total_price,
+        show_command_guests=show_command_guests,
+        show_price_per_unit=show_price_per_unit,
+        show_local_header=show_local_header,
+        show_domicile_header=show_domicile_header,
+    )
+
+
+def make_global_settings(
+    currency: str | None = "EUR",
+    iva: int = 21,
+    use_payment_terminal: bool = False,
+    use_cashmatic: bool = False,
+    use_cashlogy: bool = False,
+) -> SimpleNamespace:
+    return SimpleNamespace(
+        currency=currency,
+        iva=iva,
+        use_payment_terminal=use_payment_terminal,
+        use_cashmatic=use_cashmatic,
+        use_cashlogy=use_cashlogy,
+    )