Source code for caspia.meadow.rules.on_do

from enum import Enum

from caspia.meadow.serialization import Deserializable, Serializable

from .base import Rule


class OnDoRuleTrigger(Enum):
    ON_TRUE = 'on_true'
    ON_UPDATE = 'on_update'


class OnDoRule(Rule, Serializable, Deserializable):
    enable_duplicates = True

    def _autogenerate_name(self, on, do, trigger):
        identifier = '[generated] '
        if trigger == OnDoRuleTrigger.ON_TRUE:
            identifier += f'When {str(on)} is true'
        elif trigger == OnDoRuleTrigger.ON_UPDATE:
            identifier += f'On {str(on)}'
        else:
            return None
        identifier += f' do {str(do)}'
        return identifier

    def __init__(self, on, do, trigger=OnDoRuleTrigger.ON_TRUE, identifier=None, name=None):
        super().__init__(identifier=identifier,
                         name=name or self._autogenerate_name(on, do, trigger))
        self.on = on
        self.do = do
        self.trigger = trigger

    serialized_type = 'on-do'

    def serialize_content(self):
        if not isinstance(self.on, Serializable) or not isinstance(self.do, Serializable):
            return None
        return {
            'type': type(self).serialized_type,
            'on': self.on.serialize(),
            'do': self.do.serialize(),
            'trigger': self.trigger.value
        }

    @classmethod
    def deserialize(cls, data, context):
        on = Deserializable.deserialize(data['on'], context)
        do = Deserializable.deserialize(data['do'], context)
        identifier = data['identifier']
        trigger = OnDoRuleTrigger(data.get('trigger', OnDoRuleTrigger.ON_TRUE))
        return OnDoRule(on, do, trigger=trigger, identifier=identifier)

    def __repr__(self):
        return f'<OnDoRule {self.trigger.value} of {self.on} do {self.do}>'