Skip to content

Home Information - Your home, your data, organized.

Python
11.1 KB
Raw Blame
from typing import List, Set

from hi.simulator.services.base_models import SimEntityDefinition, SimEntityFields, SimState
from hi.simulator.services.exceptions import SimEntityValidationError
from hi.simulator.services.service_simulator import ServiceSimulator
from hi.simulator.services.sim_entity import SimEntity

from .enums import ZmMonitorFunction, ZmRunStateType
from .sim_models import (
    ZONEMINDER_SIM_ENTITY_DEFINITION_LIST,
    ZmSimMonitor,
    ZmMonitorFunctionState,
    ZmMonitorSimEntityFields,
    ZmMonitorMotionState,
    ZmSimServer,
    ZmServerRunState,
    ZmServerSimEntityFields,
    ZmSimRunState,
    ZmSimRunStateDefinition,
)
from .zm_event_manager import ZmSimEventManager


class ZoneMinderSimulator( ServiceSimulator ):

    @property
    def id(self):
        return 'zm'

    @property
    def label(self) -> str:
        return 'ZoneMinder'

    @property
    def integration_urls(self):
        return [
            ( 'API URL', 'services/zoneminder/api' ),
            ( 'Portal URL', 'services/zoneminder' ),
        ]

    def get_zm_monitor_sim_entity_list( self ) -> List[ ZmSimMonitor ]:
        return [ ZmSimMonitor( sim_entity = x ) for x in self.sim_entities
                 if x.sim_entity_definition.sim_entity_fields_class == ZmMonitorSimEntityFields ]

    def find_zm_monitor_by_id( self, monitor_id : int ) -> ZmSimMonitor:
        """Locate a monitor by its API id, or return None if no
        monitor in the active profile carries that id. Used by the
        media endpoints (thumbnail / MJPEG) to render frames with
        the correct monitor name; missing ids fall back to a
        generic placeholder rather than 404, to keep the simulator
        forgiving across profile switches that drop monitors."""
        for zm_sim_monitor in self.get_zm_monitor_sim_entity_list():
            if zm_sim_monitor.monitor_id == monitor_id:
                return zm_sim_monitor
            continue
        return None

    def post_load_hook( self ):
        # Materialize the singleton ZM Server entity at profile-load
        # time so a freshly-created or freshly-switched-to profile
        # always shows it without needing a ZM-specific request to
        # trigger the on-demand creation in get_zm_server_sim_entity.
        self.get_zm_server_sim_entity()
        return

    def get_zm_server_sim_entity( self ) -> ZmSimServer:
        for sim_entity in self.sim_entities:
            if sim_entity.sim_entity_definition.sim_entity_fields_class == ZmServerSimEntityFields:
                return ZmSimServer( sim_entity = sim_entity )
            continue

        # Auto-create a default ZoneMinder Service entity. The
        # integration's run-state queries — and therefore any sync —
        # require a server entity; ZmServerSimEntityFields has no
        # operator-configurable fields, so the only sensible operator
        # action would be to click "Add ZoneMinder Service" and accept
        # defaults. Elide that step so a fresh profile is functional out
        # of the box.
        self._auto_create_default_server_entity()
        for sim_entity in self.sim_entities:
            if sim_entity.sim_entity_definition.sim_entity_fields_class == ZmServerSimEntityFields:
                return ZmSimServer( sim_entity = sim_entity )
            continue
        raise ValueError( 'Failed to auto-create ZM server entity.' )

    def _auto_create_default_server_entity( self ):
        # Imported locally to avoid a module-load-time cycle: the
        # ServiceSimulatorManager imports the simulator subclasses at startup.
        from hi.simulator.services.service_simulator_manager import ServiceSimulatorManager

        server_definition = None
        for definition in self.sim_entity_definition_list:
            if definition.sim_entity_fields_class == ZmServerSimEntityFields:
                server_definition = definition
                break
            continue
        if server_definition is None:
            raise ValueError( 'No ZmServerSimEntityFields definition registered.' )

        try:
            ServiceSimulatorManager().add_sim_entity(
                simulator = self,
                sim_entity_definition = server_definition,
                sim_entity_fields = ZmServerSimEntityFields(),
            )
        except SimEntityValidationError:
            # Concurrent request already auto-created it. Safe to ignore;
            # the caller's re-scan of self.sim_entities will pick it up.
            pass
        return

    def get_zm_sim_run_state_list(self) -> List[ ZmSimRunState ]:

        # TODO: ZM allows run state states and its monitor functions to be
        # user-defined.  Changing the run state affects the monitor
        # function state(s), so it is non-trivial to add this to the
        # simulator. Deferring this work until there more need for this and
        # just using fixed list of run states and default monitor functions
        # for now.

        zm_server_sim_entity = self.get_zm_server_sim_entity()
        current_zm_run_state_value = zm_server_sim_entity.run_state_value
        zm_monitor_sim_entity_list = self.get_zm_monitor_sim_entity_list()

        zm_sim_run_state_list = list()
        for zm_run_state_idx, zm_run_state_type in enumerate( ZmRunStateType ):
            is_active = bool( current_zm_run_state_value == zm_run_state_type.name )
            definition_list = [
                ZmSimRunStateDefinition(
                    monitor_id = x.monitor_id,
                    monitor_function = ZmMonitorFunction.default_value(),
                ) for x in zm_monitor_sim_entity_list ]
            zm_sim_run_state = ZmSimRunState(
                zm_run_state_id = zm_run_state_idx,
                name = zm_run_state_type.name,
                definition_list = definition_list,
                is_active = is_active,
            )
            zm_sim_run_state_list.append( zm_sim_run_state )
            continue
        
        return zm_sim_run_state_list
        
    def set_monitor_function( self,
                              monitor_id           : int,
                              zm_monitor_function  : ZmMonitorFunction ) -> SimState:
        for sim_entity in self.sim_entities:
            if sim_entity.sim_entity_definition.sim_entity_fields_class == ZmMonitorSimEntityFields:
                zm_sim_monitor = ZmSimMonitor( sim_entity = sim_entity )
                if zm_sim_monitor.monitor_id == monitor_id:
                    return sim_entity.set_sim_state(
                        sim_state_id = ZmMonitorFunctionState.FUNCTION_SIM_STATE_ID,
                        value_str = zm_monitor_function.value,
                    )
            continue
        raise KeyError( f'ZM monitor with id "{monitor_id}" does not exist.' )

    def set_run_state( self, zm_run_state_type : ZmRunStateType ):

        for sim_entity in self.sim_entities:
            if sim_entity.sim_entity_definition.sim_entity_fields_class == ZmServerSimEntityFields:
                return sim_entity.set_sim_state(
                    sim_state_id = ZmServerRunState.RUNSTATE_SIM_STATE_ID,
                    value_str = zm_run_state_type.value,
                )
            continue
        raise KeyError( 'ZM server entity does not exist.' )
    
    @property
    def sim_entity_definition_list(self) -> List[ SimEntityDefinition ]:
        return ZONEMINDER_SIM_ENTITY_DEFINITION_LIST
    
    def validate_new_sim_entity_fields( self, new_sim_entity_fields : SimEntityFields ):
        if isinstance( new_sim_entity_fields, ZmMonitorSimEntityFields ):
            self._validate_monitor_fields(
                candidate_sim_entity_fields = new_sim_entity_fields,
                exclude_sim_entity_ids = set(),
            )
        elif isinstance( new_sim_entity_fields, ZmServerSimEntityFields ):
            self._validate_server_fields(
                candidate_sim_entity_fields = new_sim_entity_fields,
                exclude_sim_entity_ids = set(),
            )
        return
    
    def validate_updated_sim_entity( self, updated_sim_entity : SimEntity ):
        sim_entity_fields = updated_sim_entity.sim_entity_fields
        if isinstance( sim_entity_fields, ZmMonitorSimEntityFields ):
            self._validate_monitor_fields(
                candidate_sim_entity_fields = sim_entity_fields,
                exclude_sim_entity_ids = { updated_sim_entity.id },
            )
        elif isinstance( sim_entity_fields, ZmServerSimEntityFields ):
            self._validate_server_fields(
                candidate_sim_entity_fields = sim_entity_fields,
                exclude_sim_entity_ids = { updated_sim_entity.id },
            )
        return

    def _validate_monitor_fields( self,
                                  candidate_sim_entity_fields  : ZmMonitorSimEntityFields,
                                  exclude_sim_entity_ids       : Set[ int ] ):
        existing_monitor_ids = set()
        existing_hosts = set()
        for sim_entity in self.sim_entities:
            if sim_entity.id in exclude_sim_entity_ids:
                continue
            sim_entity_fields = sim_entity.sim_entity_fields
            if isinstance( sim_entity_fields, ZmMonitorSimEntityFields ):
                existing_monitor_ids.add( sim_entity_fields.monitor_id )
                existing_hosts.add( sim_entity_fields.host )
            continue

        candidate_monitor_id = candidate_sim_entity_fields.monitor_id
        if candidate_monitor_id in existing_monitor_ids:
            raise SimEntityValidationError(
                f'Monitor id "{candidate_monitor_id}" already used.'
            )

        candidate_host = candidate_sim_entity_fields.host
        if candidate_host in existing_hosts:
            raise SimEntityValidationError(
                f'Host "{candidate_host}" already used.'
            )
        return

    def _validate_server_fields( self,
                                 candidate_sim_entity_fields  : ZmServerSimEntityFields,
                                 exclude_sim_entity_ids       : Set[ int ] ):
        for sim_entity in self.sim_entities:
            if sim_entity.id in exclude_sim_entity_ids:
                continue
            sim_entity_fields = sim_entity.sim_entity_fields
            if isinstance( sim_entity_fields, ZmServerSimEntityFields ):
                raise SimEntityValidationError(
                    'Only one ZM server should be defined.'
                )
            continue
        return
    
    def set_sim_state( self,
                       sim_entity_id  : int,
                       sim_state_id   : str,
                       value_str      : str ) -> SimState:
        """ Need to override this so we can track ZM events based on simulated motion changes. """
        
        sim_state = super().set_sim_state(
            sim_entity_id = sim_entity_id,
            sim_state_id = sim_state_id,
            value_str = value_str,
        )
        if isinstance( sim_state, ZmMonitorMotionState ):
            sim_entity = self.get_sim_entity_by_id( sim_entity_id = sim_entity_id )
            ZmSimEventManager().add_motion_value(
                zm_sim_monitor = ZmSimMonitor( sim_entity = sim_entity ),
                motion_value = sim_state.value,
            )
        return sim_state