Source code for caspia.gateway.services.lockmechanism

import asyncio

from caspia.gateway.services import GatewayService
from caspia.meadow.client import characteristic_write_handler
from caspia.meadow.services import LockMechanismBase
from caspia.node import components


class LockMechanism(GatewayService, LockMechanismBase):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.relay_c = None
        self.state.value = 'secured'
        self.target_state.value = 'secured'
        self._target_state_pending = False

    def configure(self):
        self.relay_c = self.network.get_configured_component(self.get_node(), components.Relay,
                                                             self.config['relay'])

        if 'power' in self.config:
            self.power_c = self.network.get_configured_component(self.get_node(), components.Relay,
                                                                 self.config['power'])

    @property
    def dependant_components(self):
        return {self.relay_c}

    async def on_component_event(self, component, event):
        if self.relay_c == component:
            if isinstance(event, components.Relay.StateOnEvent):
                self.state.value = 'unsecured'
            elif isinstance(event, components.Relay.StateOffEvent):
                self.state.value = 'secured'
            if self._target_state_pending and self.target_state.value == self.state.value:
                self._target_state_pending = False
            elif not self._target_state_pending:
                self.target_state.value = self.state.value

    @characteristic_write_handler('target_state')
    async def target_state_write(self, value, **kwargs):
        if value != self.state.value:
            self._target_state_pending = True
            asyncio.ensure_future(self._switch_state(value))

    async def _switch_state(self, target_state):
        if target_state == 'secured':
            await self.relay_c.off()
        elif target_state == 'unsecured':
            await self.relay_c.on()
        else:
            raise ValueError('Invalid value %r' % target_state)