printer-core 0.0.1__py3-none-any.whl

printer_core/__init__.py

@@ -0,0 +1 @@
+# printer_core package

printer_core/algorithms/__init__.py

@@ -0,0 +1,3 @@
+from .products_modifiers_multiprinter import ProductsModifiersMultiPrinter
+from .products_modifiers_multiprinter_family import ProductsModifiersMultiprinterFamily
+from .products_modifiers_unique_ticket import ProductsModifiersUniqueTicket

printer_core/algorithms/products_modifiers_multiprinter.py

@@ -0,0 +1,59 @@
+from typing import Any
+
+from printer_core.entities import KitchenProductLine, PrintProductData, PrintRequestData, PrinterData
+from printer_core.formatters.discount_formatter import DiscountFormatter
+
+
+class ProductsModifiersMultiPrinter:
+    def __init__(self, formatter: DiscountFormatter):
+        self._formatter = formatter
+
+    def build(
+        self,
+        request: PrintRequestData,
+        products: list[PrintProductData],
+        kitchen_ticket_settings: Any,
+        main_printer: PrinterData | dict[str, Any],
+    ) -> list[KitchenProductLine]:
+        list_products_own_printer: list[KitchenProductLine] = []
+        fallback_printer = self._resolve_printer(main_printer)
+        for product in products:
+            printers = list(product.printer or [])
+            if not printers:
+                printers = [fallback_printer]
+            for actual_printer in printers:
+                printer_payload = self._resolve_printer(actual_printer)
+                name = product.product_name
+                if kitchen_ticket_settings.show_price_per_unit and not request.all_discounted:
+                    name += self._formatter.format(product, request.currency or "")
+                line = KitchenProductLine(
+                    name=name,
+                    qty=int(product.qty),
+                    option=product.option,
+                    printer_r=printer_payload.name,
+                    printer_w=printer_payload.printer_width,
+                    details=product.details or "",
+                    order=product.order or "",
+                    tpv=printer_payload.tpv,
+                    order_readable=product.order_readable or "",
+                )
+                if kitchen_ticket_settings.show_price_per_unit:
+                    line = line.model_copy(update={
+                        "price": product.total_price,
+                        "unitary_price": product.product_price,
+                    })
+                list_products_own_printer.append(line)
+        return list_products_own_printer
+
+    def _resolve_printer(self, printer: PrinterData | dict[str, Any]) -> PrinterData:
+        if isinstance(printer, PrinterData):
+            return printer
+        if isinstance(printer, dict):
+            return PrinterData(**printer)
+        if hasattr(printer, "model_dump"):
+            return PrinterData(**printer.model_dump(mode="json", exclude_none=True))
+        return PrinterData(
+            name=printer.name,
+            printer_width=printer.printer_width,
+            tpv=getattr(printer, "tpv", None),
+        )

printer_core/algorithms/products_modifiers_multiprinter_family.py

@@ -0,0 +1,53 @@
+from typing import Any
+
+from printer_core.entities import KitchenProductLine, PrintProductData, PrintRequestData, PrinterData
+from printer_core.formatters.discount_formatter import DiscountFormatter
+
+
+class ProductsModifiersMultiprinterFamily:
+    def __init__(self, formatter: DiscountFormatter):
+        self._formatter = formatter
+
+    def append_product(self,
+                       list_products_own_printer: list[KitchenProductLine],
+                       product: PrintProductData,
+                       request: PrintRequestData,
+                       kitchen_ticket_settings: Any,
+                       ) -> None:
+        for actual_printer in product.printer:
+            printer_payload = self._resolve_printer(actual_printer)
+            name_with_discount: str = product.product_name
+            if not request.all_discounted:
+                name_with_discount += self._formatter.format(product, request.currency or "")
+            line = KitchenProductLine(
+                name=name_with_discount,
+                qty=int(product.qty),
+                option=product.option,
+                printer_r=printer_payload.name,
+                printer_w=printer_payload.printer_width,
+                details=product.details or "",
+                order=product.order or "",
+                tpv=printer_payload.tpv,
+                order_readable=product.order_readable or "",
+            )
+
+            if kitchen_ticket_settings.show_price_per_unit:
+                line = line.model_copy(update={
+                    "price": product.total_price,
+                    "unitary_price": product.product_price,
+                })
+
+            list_products_own_printer.append(line)
+
+    def _resolve_printer(self, printer: PrinterData | dict[str, Any]) -> PrinterData:
+        if isinstance(printer, PrinterData):
+            return printer
+        if isinstance(printer, dict):
+            return PrinterData(**printer)
+        if hasattr(printer, "model_dump"):
+            return PrinterData(**printer.model_dump(mode="json", exclude_none=True))
+        return PrinterData(
+            name=printer.name,
+            printer_width=printer.printer_width,
+            tpv=getattr(printer, "tpv", None),
+        )

printer_core/algorithms/products_modifiers_unique_ticket.py

@@ -0,0 +1,30 @@
+from printer_core.entities import ClientTicketProduct, PrintProductData, PrintRequestData
+from printer_core.formatters.discount_formatter import DiscountFormatter
+
+
+class ProductsModifiersUniqueTicket:
+    def __init__(self, formatter: DiscountFormatter, domicile_service_label: str = "Domicile Service"):
+        self._formatter = formatter
+        self._domicile_service_label = domicile_service_label
+
+    def build(self, request: PrintRequestData, products: list[PrintProductData]) -> list[ClientTicketProduct]:
+        list_products_in_same_printers: list[ClientTicketProduct] = []
+        for product in products:
+            with_discount = ""
+            if not request.all_discounted:
+                with_discount = self._formatter.format(product, request.currency or "")
+            product_name = product.product_name + with_discount
+            list_products_in_same_printers.append(ClientTicketProduct(
+                name=product_name,
+                qty=int(product.qty),
+                option=product.option,
+                price=str(product.total_price),
+                unitary_price=str(product.product_price),
+            ))
+        if request.price_domicile_service:
+            list_products_in_same_printers.append(ClientTicketProduct(
+                name=self._domicile_service_label,
+                qty=1,
+                price=str(request.price_domicile_service),
+            ))
+        return list_products_in_same_printers

printer_core/builders/__init__.py

@@ -0,0 +1,4 @@
+from .kitchen_ticket_payload_builder import KitchenTicketPayloadBuilder
+from .printer_products_grouper import PrinterProductsGrouper
+from .client_ticket_builder import ClientTicketBuilder
+from .header_builder import HeaderBuilder

printer_core/builders/client_ticket_builder.py

@@ -0,0 +1,97 @@
+from decimal import Decimal
+from typing import Any, Callable
+
+from printer_core.entities import (
+    ClientTicketData,
+    ClientTicketPayload,
+    ClientTicketProduct,
+    PrintProductData,
+    PrintRequestData,
+    PrinterData,
+)
+
+
+class ClientTicketBuilder:
+    def __init__(self,
+                 currency_symbol_resolver: Callable[[str], str] | None = None,
+                 domicile_service_label: str = "Domicile Service",
+                 ):
+        self._currency_symbol_resolver = currency_symbol_resolver or (lambda _: "")
+        self._domicile_service_label = domicile_service_label
+
+    def build(self,
+              request: PrintRequestData,
+              products: list[PrintProductData],
+              printer: PrinterData | dict[str, Any],
+              ticket_settings: Any,
+              tpv_key: str,
+              ) -> list[ClientTicketPayload]:
+        ticket_text = self._get_attr(ticket_settings, "ticket_text", "")
+        qty_client_ticket = self._get_attr(ticket_settings, "qty_client_ticket", 1)
+        client_request = ClientTicketData(
+            **request.model_dump(exclude={"products", "ticket_text"}),
+            ticket_text=ticket_text,
+            products=self._build_products(request, products),
+        )
+
+        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})
+
+        printer_name, printer_width = self._resolve_printer(printer)
+        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_width,
+        )
+        return [payload]
+
+    def _build_products(
+        self,
+        request: PrintRequestData,
+        products: list[PrintProductData],
+    ) -> list[ClientTicketProduct]:
+        list_products: list[ClientTicketProduct] = []
+        currency_symbol = self._currency_symbol_resolver(request.currency or "")
+        for product in products:
+            with_discount = ""
+            if not request.all_discounted:
+                with_discount = self._format_discount(product, currency_symbol)
+            product_name = product.product_name + with_discount
+            list_products.append(ClientTicketProduct(
+                name=product_name,
+                qty=int(product.qty),
+                option=product.option,
+                price=str(product.total_price),
+                unitary_price=str(product.product_price),
+            ))
+        if request.price_domicile_service:
+            list_products.append(ClientTicketProduct(
+                name=self._domicile_service_label,
+                qty=1,
+                price=str(request.price_domicile_service),
+            ))
+        return list_products
+
+    def _format_discount(self, product: PrintProductData, currency_symbol: str) -> str:
+        if product.discount_type == "number":
+            return f" (Dto {product.total_price}{currency_symbol})"
+        if product.discount_type == "percent" and product.discount:
+            total = Decimal(str(product.importe)) - Decimal(str(product.total_price))
+            return f" (Dto {product.discount.value}% {total}{currency_symbol})"
+        return ""
+
+    def _get_attr(self, obj: Any, attr: str, default: Any) -> Any:
+        if isinstance(obj, dict):
+            return obj.get(attr, default)
+        return getattr(obj, attr, default)
+
+    def _resolve_printer(self, printer: PrinterData | dict[str, Any]) -> tuple[str, Any]:
+        if isinstance(printer, dict):
+            return printer["name"], printer["printer_width"]
+        return printer.name, printer.printer_width

printer_core/builders/header_builder.py

@@ -0,0 +1,26 @@
+from typing import Any
+
+from printer_core.entities import HeaderData, PrintRequestData
+from printer_core.ports import HeaderDataProvider
+
+
+class HeaderBuilder:
+    def __init__(self, provider: HeaderDataProvider, show_person_name: bool):
+        self._provider = provider
+        self._show_person_name = show_person_name
+
+    def build_header(self, request: PrintRequestData, worker: Any | None = None) -> HeaderData:
+        header_data: dict[str, str] = self._provider.get_company_header()
+        if self._show_person_name and worker:
+            header_data.update(self._provider.get_worker_header(worker))
+        header_data.update(self._client_header(request))
+        return HeaderData(**header_data)
+
+    def _client_header(self, request: PrintRequestData) -> dict[str, str]:
+        request_type = request.type
+        from_client = request.from_client
+        if request_type == "recoger":
+            return self._provider.get_pickup_client_header(request.client, from_client)
+        if request_type == "domicilio":
+            return self._provider.get_domicile_client_header(request.address, from_client)
+        return {}

printer_core/builders/kitchen_ticket_payload_builder.py

@@ -0,0 +1,99 @@
+from datetime import datetime
+from typing import Any, Callable
+
+from printer_core.clock import SystemClock
+from printer_core.entities import (
+    KitchenProductLine,
+    KitchenTicketData,
+    KitchenTicketPayload,
+    PrintRequestData,
+    PrintSettingsData,
+    ProductsGroup,
+)
+from printer_core.ports import Clock
+
+
+class KitchenTicketPayloadBuilder:
+    def __init__(self, clock: Clock | None = None):
+        self._clock = clock or SystemClock()
+
+    def build(self,
+              request: PrintRequestData,
+              printer_name: str,
+              tpv_key: str,
+              printer_width: str,
+              products: list[KitchenProductLine],
+              ticket_settings: Any,
+              kitchen_ticket_settings: Any,
+              group_products_func: Callable[[list[KitchenProductLine]], list[ProductsGroup]],
+              ) -> KitchenTicketPayload:
+        data = KitchenTicketData(
+            id=request.id,
+            table_name=request.table_name,
+            credit_card=request.credit_card,
+            serial=request.serial,
+            details=request.details or "",
+            type=request.type,
+            discount=request.discount,
+        )
+
+        data = data.model_copy(update={"created_at": self._resolve_created_at(request)})
+
+        if kitchen_ticket_settings.show_total_price:
+            data = data.model_copy(update={
+                "total": str(request.total),
+                "request_price": request.request_price,
+            })
+
+        if request.type == "local" and kitchen_ticket_settings.show_command_guests:
+            data = data.model_copy(update={"command_guests": request.command_guests})
+
+        if request.headerData:
+            data = data.model_copy(update={"headerData": request.headerData})
+
+        model = 1
+        if request.type != "local":
+            model = 2
+
+        data = self._set_products(data, request, products, group_products_func)
+        print_settings = self._set_print_settings(request)
+
+        return KitchenTicketPayload(
+            data=data,
+            model=model,
+            printer_qty=ticket_settings.qty_kitchen_ticket,
+            printer=printer_name,
+            company_key=tpv_key,
+            printer_width=printer_width,
+            currency=request.currency or "",
+            PrintSettings=print_settings,
+        )
+
+    def _resolve_created_at(self, request: PrintRequestData) -> str:
+        if request.type in ["domicilio", "recoger"] and request.shift_time and request.delivery_date:
+            shift_time = datetime.strptime(request.shift_time, "%H:%M").time()
+            delivery_date = datetime.strptime(request.delivery_date, "%Y-%m-%d").date()
+            return datetime.combine(delivery_date, shift_time).strftime("%Y-%m-%d %H:%M")
+        return self._clock.now_iso()
+
+    def _set_products(self,
+                      data: KitchenTicketData,
+                      request: PrintRequestData,
+                      products: list[KitchenProductLine],
+                      group_products_func: Callable[[list[KitchenProductLine]], list[ProductsGroup]],
+                      ) -> KitchenTicketData:
+        group_by_orders = request.group_by_orders
+        if group_by_orders and request.type == "local":
+            grouped = group_products_func(products)
+            if grouped and not isinstance(grouped[0], ProductsGroup):
+                grouped = [ProductsGroup(group="Sin orden", products=grouped)]
+            return data.model_copy(update={"products_groups": grouped})
+        return data.model_copy(update={"products": products})
+
+    def _set_print_settings(self, request: PrintRequestData) -> PrintSettingsData | None:
+        print_settings = request.PrintSettings
+        if not print_settings:
+            return None
+        if request.type == "local" and print_settings.show_local_header is not None:
+            return print_settings.model_copy(update={"show_header": print_settings.show_local_header})
+        return print_settings

printer_core/builders/printer_products_grouper.py

@@ -0,0 +1,19 @@
+from printer_core.entities import KitchenProductLine, PrinterProductGroup
+
+
+class PrinterProductsGrouper:
+    @staticmethod
+    def group_by_printer_key(products: list[KitchenProductLine]) -> list[PrinterProductGroup]:
+        grouped: dict[str, PrinterProductGroup] = {}
+        for item in products:
+            key = f"{item.printer_r}%%{item.tpv or ''}%%{item.printer_w}"
+            if key not in grouped:
+                grouped[key] = PrinterProductGroup(
+                    printer_name=item.printer_r,
+                    tpv_key=item.tpv or "",
+                    printer_width=item.printer_w,
+                    products=[item],
+                )
+            else:
+                grouped[key].products.append(item)
+        return list(grouped.values())

printer_core/clock.py

@@ -0,0 +1,6 @@
+from datetime import datetime, timezone
+
+
+class SystemClock:
+    def now_iso(self) -> str:
+        return datetime.now(timezone.utc).isoformat()

printer_core/context/__init__.py

@@ -0,0 +1 @@
+from .ticket_context_builder import TicketContextBuilder

printer_core/context/ticket_context_builder.py

@@ -0,0 +1,55 @@
+from typing import Any
+
+from printer_core.entities import PrintRequestData, PrintSettingsData
+from printer_core.ports import HeaderProvider, PrintSettingsBuilder
+
+
+class TicketContextBuilder:
+    def __init__(self, header_provider: HeaderProvider, print_settings_builder: PrintSettingsBuilder):
+        self._header_provider = header_provider
+        self._print_settings_builder = print_settings_builder
+
+    def apply_kitchen_context(self,
+                              request: PrintRequestData,
+                              ticket_settings: Any,
+                              kitchen_ticket_settings: Any,
+                              header_mode: str,
+                              include_print_by: bool = True,
+                              worker: Any | None = None,
+                              ) -> PrintRequestData:
+        updates: dict[str, Any] = {
+            "order_by": ticket_settings.order_by if ticket_settings.order_by else "name",
+            "group_by_orders": kitchen_ticket_settings.group_by_orders,
+            "PrintSettings": self._print_settings_builder.build(kitchen_ticket_settings),
+        }
+        if include_print_by:
+            updates["print_by"] = kitchen_ticket_settings.print_by
+        if self._should_add_header(kitchen_ticket_settings, header_mode):
+            header_data = self._header_provider.build_header(request, worker=worker)
+            updates["headerData"] = header_data
+        return request.model_copy(update=updates)
+
+    def apply_client_context(self,
+                             request: PrintRequestData,
+                             kitchen_ticket_settings: Any,
+                             include_header: bool = True,
+                             details_font_none: bool = True,
+                             worker: Any | None = None,
+                             ) -> PrintRequestData:
+        print_settings: PrintSettingsData = self._print_settings_builder.build(kitchen_ticket_settings)
+        if details_font_none:
+            print_settings = print_settings.model_copy(update={"details_font": None})
+        updates: dict[str, Any] = {"PrintSettings": print_settings}
+        if include_header:
+            header_data = self._header_provider.build_header(request, worker=worker)
+            updates["headerData"] = header_data
+        return request.model_copy(update=updates)
+
+    def _should_add_header(self, kitchen_ticket_settings: Any, header_mode: str) -> bool:
+        match header_mode:
+            case "local":
+                return kitchen_ticket_settings.show_local_header
+            case "domicile":
+                return kitchen_ticket_settings.show_domicile_header
+            case _:
+                return False

printer_core/dispatchers/__init__.py

@@ -0,0 +1,2 @@
+from .kitchen_ticket_dispatcher import KitchenTicketDispatcher
+from .payload_dispatcher import PayloadDispatcher

printer_core/dispatchers/kitchen_ticket_dispatcher.py

@@ -0,0 +1,34 @@
+from typing import Any, Callable
+
+from printer_core.builders.kitchen_ticket_payload_builder import KitchenTicketPayloadBuilder
+from printer_core.entities import KitchenProductLine, KitchenTicketPayload, PrintRequestData, PrinterProductGroup, ProductsGroup
+from printer_core.ports import PrinterGateway
+
+
+class KitchenTicketDispatcher:
+    def __init__(self, gateway: PrinterGateway, builder: KitchenTicketPayloadBuilder | None = None):
+        self._builder = builder or KitchenTicketPayloadBuilder()
+        self._gateway = gateway
+
+    def dispatch(self,
+                 request: PrintRequestData,
+                 grouped_products: list[PrinterProductGroup],
+                 ticket_settings: Any,
+                 kitchen_ticket_settings: Any,
+                 group_products_func: Callable[[list[KitchenProductLine]], list[ProductsGroup]],
+                 ) -> list[KitchenTicketPayload]:
+        final_request: list[KitchenTicketPayload] = []
+        for group in grouped_products:
+            payload = self._builder.build(
+                request=request,
+                printer_name=group.printer_name,
+                tpv_key=group.tpv_key,
+                printer_width=group.printer_width,
+                products=group.products,
+                ticket_settings=ticket_settings,
+                kitchen_ticket_settings=kitchen_ticket_settings,
+                group_products_func=group_products_func,
+            )
+            final_request.append(payload)
+            self._gateway.send_data(group.tpv_key, [payload.model_dump(mode="json", exclude_none=True)])
+        return final_request

printer_core/dispatchers/payload_dispatcher.py

@@ -0,0 +1,18 @@
+from typing import Any
+
+from printer_core.ports import PrinterGateway
+
+
+class PayloadDispatcher:
+    def __init__(self, gateway: PrinterGateway):
+        self._gateway = gateway
+
+    def send(self, tpv_key: str, payload: Any) -> None:
+        if hasattr(payload, "model_dump"):
+            payload = payload.model_dump(mode="json", exclude_none=True)
+        if isinstance(payload, list):
+            payload = [
+                item.model_dump(mode="json", exclude_none=True) if hasattr(item, "model_dump") else item
+                for item in payload
+            ]
+        self._gateway.send_data(tpv_key, payload)

printer_core/entities/__init__.py

@@ -0,0 +1,53 @@
+from .print_context import PrintContext
+from .print_models import (
+    ClientTicketData,
+    ClientTicketPayload,
+    ClientTicketProduct,
+    CompanyHeaderData,
+    DiscountData,
+    FamilyData,
+    FiskalyData,
+    HeaderData,
+    IvaData,
+    KitchenProductLine,
+    KitchenTicketData,
+    KitchenTicketPayload,
+    MarchCommandData,
+    PrintSettingsData,
+    PrintChannel,
+    PrintJob,
+    PrintResult,
+    PrintProductData,
+    PrintRequestData,
+    PrinterData,
+    PrinterProductGroup,
+    ProductsGroup,
+    WorkerData,
+)
+
+__all__ = [
+    "ClientTicketPayload",
+    "ClientTicketProduct",
+    "ClientTicketData",
+    "CompanyHeaderData",
+    "DiscountData",
+    "FamilyData",
+    "FiskalyData",
+    "HeaderData",
+    "IvaData",
+    "KitchenProductLine",
+    "KitchenTicketData",
+    "KitchenTicketPayload",
+    "MarchCommandData",
+    "PrintContext",
+    "PrintSettingsData",
+    "PrintChannel",
+    "PrintJob",
+    "PrintResult",
+    "PrintProductData",
+    "PrintRequestData",
+    "PrinterData",
+    "PrinterProductGroup",
+    "ProductsGroup",
+    "WorkerData",
+]

printer_core/entities/print_context.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from printer_core.entities.print_models import PrinterData, WorkerData
+
+
+@dataclass(frozen=True)
+class PrintContext:
+    ticket_settings: Any
+    kitchen_settings: Any
+    global_settings: Any
+    main_printer: PrinterData
+    worker: WorkerData | None = None