switch.py

from typing import Any, Callable, Dict, List, Mapping, Optional, Set, Tuple

from odoo import api, models

from .base import ContextBuilder, Converter, Skip
from .validate import VALIDATION_SKIP, Validator


class Switch(Converter):
    """A converter to handle switch cases.
    A list of converters are provided with a function. The first function to
    match is used, any function that is None will be used.
    The function argument is the model instance.

    Example usage:

    .. code-block:: python

        AURION_REFERENTIAL: Switch(
            [
              (
                  lambda e: e.is_xxx,
                  lambda p: "wave_code" in p,
                  Model("__wave__", {}),
              ),
              (None, None, Model("__event__", {})),
            ]
        )
    """

    def __init__(
        self,
        converters: List[
            Tuple[
                Callable[[models.Model], bool],
                Callable[[Any], bool],
                Converter,
            ]
        ],
        validator: Optional[Validator] = None,
        validation: str = VALIDATION_SKIP,
        context: Optional[ContextBuilder] = None,
    ):
        """
        :param converters: is a 3 tuple composed of:
        out condition, in condition, and chosen converter
        :param validator:
        :param context:
        """
        super()
        self._converters = converters
        self.context = context
        self.validator = validator
        self.validation = validation

    def odoo_to_message(
        self, instance: models.Model, ctx: Optional[Mapping] = None
    ) -> Any:
        for out_cond, _in_cond, converter in self._converters:
            if out_cond is None or out_cond(instance):
                return converter.odoo_to_message(instance, ctx)

        return None

    def message_to_odoo(
        self,
        odoo_env: api.Environment,
        phase: str,
        message_value: Any,
        instance: models.Model,
        value_present: bool = True,
    ) -> Dict:
        for _out_cond, in_cond, converter in self._converters:
            if in_cond is None or in_cond(message_value):
                return converter.message_to_odoo(
                    odoo_env,
                    phase,
                    message_value,
                    instance,
                    value_present=value_present,
                )

        return Skip

    def is_instance_getter(self) -> bool:
        for _out_cond, _in_cond, converter in self._converters:
            if converter.is_instance_getter():
                return True

        return False

    def get_instance(self, odoo_env, message_data):
        for _out_cond, in_cond, converter in self._converters:
            if converter.is_instance_getter() and (
                in_cond is None or in_cond(message_data)
            ):
                return converter.get_instance(odoo_env, message_data)

    @Converter.validator.setter
    def validator(self, value: Optional[Validator]) -> None:
        # also set validator on any converters in our switch, in case they care
        Converter.validator.fset(self, value)
        for _out_cond, _in_cond, converter in self._converters:
            converter.validator = value

    @Converter.validation.setter
    def validation(self, value: str) -> None:
        # also set validation on any converters in our switch
        Converter.validation.fset(self, value)
        for _out_cond, _in_cond, converter in self._converters:
            converter.validation = value

    def get__type__(self) -> Set[str]:
        types = set()
        for _out_cond, _in_cond, converter in self._converters:
            types.update(converter.get__type__())
        return types