Skip to content

Home Information - Your home, your data, organized.

Python

Added simulator ZoneMinder event management.

Anthony Cassandraf0398f293ced
diff --git a/src/hi/services/zoneminder/monitors.py b/src/hi/services/zoneminder/monitors.py
index c42d0ff6..5ffc3c48 100644
--- a/src/hi/services/zoneminder/monitors.py
+++ b/src/hi/services/zoneminder/monitors.py
@@ -32,12 +32,6 @@ class ZoneMinderMonitor( PeriodicMonitor, ZoneMinderMixin, SensorResponseMixin )
self._start_processed_event_ids = TTLCache( maxsize = 1000, ttl = 100000 )
self._zm_tzname = None
- # pyzm parses the "from" time as a naive time and applies the
- # timezone separately. It will parse an ISO time with a timezone,
- # but ignores it ignores its encoded timezone. Thus, it is
- # important that we have this in the same TZ as the ZoneMinder
- # server and also pass in the TZ when filtering events.
- #
self._poll_from_datetime = None
self._was_initialized = False
return
@@ -46,23 +40,14 @@ class ZoneMinderMonitor( PeriodicMonitor, ZoneMinderMixin, SensorResponseMixin )
zm_manager = await self.zm_manager_async()
_ = await self.sensor_response_manager_async() # Allows async use of self.sensor_response_manager()
self._zm_tzname = await sync_to_async( zm_manager.get_zm_tzname )()
- self._poll_from_datetime = datetimeproxy.now( self._zm_tzname )
+ self._poll_from_datetime = datetimeproxy.now()
zm_manager.register_change_listener( self.refresh )
self._was_initialized = True
return
def refresh( self ):
""" Should be called when integration settings are changed (via listener callback). """
- new_tzname = self.zm_manager().get_zm_tzname()
- if new_tzname == self._zm_tzname:
- return
-
- logger.info( f'Refreshing ZoneMinder monitor timezone: {self._zm_tzname} -> {new_tzname}' )
- self._poll_from_datetime = datetimeproxy.change_timezone(
- original_datetime = self._poll_from_datetime,
- new_tzname = new_tzname,
- )
- self._zm_tzname = new_tzname
+ self._zm_tzname = self.zm_manager().get_zm_tzname()
return
async def do_work(self):
@@ -81,8 +66,20 @@ class ZoneMinderMonitor( PeriodicMonitor, ZoneMinderMixin, SensorResponseMixin )
async def _process_events(self):
current_poll_datetime = datetimeproxy.now()
+
+ # The pyzm ZM client library parses the "from" time as a naive time
+ # and applies the timezone separately. pyzm will parse an ISO time
+ # with a timezone, but pyzm ignores ignores the ISO time's encoded
+ # timezone. Thus, it is important that we have thisn "poll from"
+ # in the same TZ as the ZoneMinder server and that we also pass
+ # the TZ when filtering events.
+ #
+ tz_adjusted_poll_from_datetime = datetimeproxy.change_timezone(
+ original_datetime = self._poll_from_datetime,
+ new_tzname = self._zm_tzname,
+ )
options = {
- 'from': self._poll_from_datetime.isoformat(), # This "from" only looks at event start time
+ 'from': tz_adjusted_poll_from_datetime.isoformat(), # "from" only looks at event start time
'tz': self._zm_tzname,
}
events = self.zm_manager().get_zm_events( options = options )
@@ -168,7 +165,7 @@ class ZoneMinderMonitor( PeriodicMonitor, ZoneMinderMixin, SensorResponseMixin )
#
closed_zm_event_list.sort( key = lambda zm_event : zm_event.end_datetime )
self._poll_from_datetime = closed_zm_event_list[-1].end_datetime
-
+
else:
# N.B. When there are no events, we do not advance the polling
# base time. We do not know whether an event might have started
diff --git a/src/hi/services/zoneminder/zm_models.py b/src/hi/services/zoneminder/zm_models.py
index 3ae6c49c..bd7b369e 100644
--- a/src/hi/services/zoneminder/zm_models.py
+++ b/src/hi/services/zoneminder/zm_models.py
@@ -10,10 +10,11 @@ from .zm_manager import ZoneMinderManager
class ZmEvent:
def __init__( self, zm_api_event : ZmApiEvent, zm_tzname : str ):
+ zm_event_dict = zm_api_event.get()
self._event_id = zm_api_event.id()
self._monitor_id = zm_api_event.monitor_id()
- self._start_datetime = self._to_datetime( zm_api_event.get()['StartTime'],zm_tzname )
- self._end_datetime = self._to_datetime( zm_api_event.get()['EndTime'], zm_tzname )
+ self._start_datetime = self._to_datetime( zm_event_dict['StartTime'], zm_tzname )
+ self._end_datetime = self._to_datetime( zm_event_dict['EndTime'], zm_tzname )
self._cause = zm_api_event.cause()
self._duration_secs = zm_api_event.duration()
try:
@@ -26,7 +27,7 @@ class ZmEvent:
self._alarmed_frame_count = 0
self._score = zm_api_event.score()
self._notes = zm_api_event.notes()
- self._max_score_frame_id = zm_api_event.get()['MaxScoreFrameId']
+ self._max_score_frame_id = zm_event_dict['MaxScoreFrameId']
return
@property
diff --git a/src/hi/simulator/base_models.py b/src/hi/simulator/base_models.py
index c313419b..4335a317 100644
--- a/src/hi/simulator/base_models.py
+++ b/src/hi/simulator/base_models.py
@@ -2,6 +2,8 @@ from dataclasses import dataclass, fields, MISSING
from datetime import datetime
from typing import Any, Dict, List, Tuple, Type
+import hi.apps.common.datetimeproxy as datetimeproxy
+
from .enums import SimEntityType, SimStateType
@@ -96,13 +98,18 @@ class SimState:
# Subclasses may provide a default value for this.
value : Any = None
+ value_datetime : datetime = None
+
@property
def name(self):
return self.sim_entity_fields.name
def set_value_from_string( self, value_str : str ):
""" Subclasses should override this is the value is not a string and needs conversion. """
+ if self.value == value_str:
+ return
self.value = value_str
+ self.value_datetime = datetimeproxy.now()
return
@property
@@ -119,6 +126,13 @@ class SimState:
def choices(self) -> List[ Tuple[ str, str ]]:
""" Subclasses using SimStateType.DISCRETE should override this to provide the valid values. """
return list()
+
+ def copy_value( self, other_sim_state : 'SimState' ):
+ if not other_sim_state:
+ return
+ self.value = other_sim_state.value
+ self.value_datetime = other_sim_state.value_datetime
+ return
@dataclass
diff --git a/src/hi/simulator/services/zoneminder/api/urls.py b/src/hi/simulator/services/zoneminder/api/urls.py
index 4f481ddc..80f416a5 100644
--- a/src/hi/simulator/services/zoneminder/api/urls.py
+++ b/src/hi/simulator/services/zoneminder/api/urls.py
@@ -24,7 +24,7 @@ urlpatterns = [
views.StatesView.as_view(),
name = 'zm_api_states' ),
- re_path( r'^events/index/(?P<filter>.+)$',
+ re_path( r'^events/index/(?P<filter>.+).json$',
views.EventsIndexView.as_view(),
name = 'zm_api_events_index' ),
]
diff --git a/src/hi/simulator/services/zoneminder/api/views.py b/src/hi/simulator/services/zoneminder/api/views.py
index eb1da40f..219cb563 100644
--- a/src/hi/simulator/services/zoneminder/api/views.py
+++ b/src/hi/simulator/services/zoneminder/api/views.py
@@ -1,14 +1,19 @@
-from datetime import timedelta
+from datetime import datetime
import logging
+import pytz
+from urllib.parse import unquote
+from typing import Dict, Any
+from django.core.exceptions import BadRequest
from django.http import JsonResponse
from django.utils.decorators import method_decorator
from django.views.decorators.csrf import csrf_exempt
from django.views.generic import View
-import hi.apps.common.datetimeproxy as datetimeproxy
-
+from hi.simulator.services.zoneminder.constants import ZmSimConstants
from hi.simulator.services.zoneminder.simulator import ZoneMinderSimulator
+from hi.simulator.services.zoneminder.sim_models import ZmPagination
+from hi.simulator.services.zoneminder.zm_event_manager import ZmSimEventManager
logger = logging.getLogger(__name__)
@@ -74,70 +79,81 @@ class StatesView( View ):
class EventsIndexView( View ):
def get(self, request, *args, **kwargs):
- return JsonResponse({
- 'events': [ ],
- 'pagination': {
- 'page': 1,
- 'current': 1,
- 'count': 1,
- 'prevPage': False,
- 'nextPage': False,
- 'pageCount': 1,
- 'order': {
- 'Event.StartTime': 'desc'
- },
- 'limit': 100,
- 'options': {
- 'order': {
- 'Event.StartTime': 'desc'
- },
- 'sort': 'StartTime',
- 'direction': 'desc'
- },
- 'paramType': 'querystring',
- 'queryScope': None,
- },
-
- })
-
-
-
+ try:
+ event_filter = kwargs.get('filter')
+ filter_dict = self.parse_event_filter( event_filter = event_filter )
+ if (( 'StartTime' not in filter_dict )
+ or ( len(filter_dict) != 1 )):
+ raise BadRequest( 'StartTime event filtering is only currently supported' )
+ start_time_filter = filter_dict.get( 'StartTime' )
+ filter_operator = start_time_filter.get( 'operator' )
+ filter_value_datetime = start_time_filter.get( 'value_datetime' )
+
+ if filter_operator != '>=':
+ raise BadRequest( 'Only ">=" event filter operator is currently supported.' )
+
+ zm_event_manager = ZmSimEventManager()
+ zm_sim_run_state_list = zm_event_manager.get_events_by_start_datetime(
+ start_datetime = filter_value_datetime,
+ )
+ zm_pagination = ZmPagination(
+ page = 1,
+ )
+ return JsonResponse({
+ 'events': [ x.to_api_dict() for x in zm_sim_run_state_list ],
+ 'pagination': zm_pagination.to_api_dict(),
+ })
+ except Exception as e:
+ logger.exception( 'Problem processing ZM events API request', e )
+ return JsonResponse({
+ 'events': [ ],
+ 'pagination': ZmPagination( page = 1 ).to_api_dict(),
+ })
+ def parse_event_filter( self, event_filter: str) -> Dict[str, Any]:
+ """
+ Parses a ZoneMinder-style event filter string into a dictionary.
+ Args:
+ event_filter (str): The URL-encoded filter string (e.g., "StartTime%20%3E=:2025-01-16%2012:18:53").
+ Returns:
+ Dict[str, Any]: A dictionary with filter keys and their parsed operations and values.
+ """
+ tz = pytz.timezone( ZmSimConstants.TIMEZONE_NAME )
- zm_monitor = ZmMonitor(
- id = 1,
- name = 'SideCamera',
- )
-
- start_ago_secs = 45
- end_ago_secs = 39
- start_datetime = datetimeproxy.now() - timedelta( seconds = start_ago_secs )
- end_datetime = datetimeproxy.now() - timedelta( seconds = end_ago_secs )
- zm_event = ZmEvent(
- zm_monitor = zm_monitor,
- event_id = 1,
- start_datetime = start_datetime,
- end_datetime = end_datetime,
- name = 'Event 1',
- cause = 'Hardcoded',
- length_secs = 5.5,
- total_frames = 15,
- alarm_frames = 6,
- total_score = 123,
- average_score = 85,
- max_score = 140,
- )
- zm_pagination = ZmPagination(
- page = 1,
- )
- return JsonResponse({
- 'events': [ zm_event.to_api_dict() ],
- 'pagination': zm_pagination.to_api_dict(),
-
- })
-
+ filters = {}
+ decoded_filter = unquote(event_filter)
+ filter_parts = decoded_filter.split(',')
+
+ for part in filter_parts:
+ if ':' in part:
+ key_operator, value = part.split( ':', 1 )
+
+ if '>' in key_operator:
+ key, operator = key_operator.split( '>', 1 )
+ operator = '>' + operator
+ elif '<' in key_operator:
+ key, operator = key_operator.split( '<', 1 )
+ operator = '<' + operator
+ elif '=' in key_operator:
+ key, operator = key_operator.split( '=', 1 )
+ operator = '=' + operator
+ else:
+ raise ValueError(f"Invalid filter format: {part}")
+
+ try:
+ value_datetime = tz.localize( datetime.strptime( value.strip(), "%Y-%m-%d %H:%M:%S" ))
+ filters[key.strip()] = {
+ 'operator': operator.strip(),
+ 'value_datetime': value_datetime,
+ }
+ except ValueError as ve:
+ logger.exception( f'Problem parsing filter date: {value}', ve )
+ continue
+
+
+ return filters
diff --git a/src/hi/simulator/services/zoneminder/constants.py b/src/hi/simulator/services/zoneminder/constants.py
new file mode 100644
index 00000000..f66174a4
--- /dev/null
+++ b/src/hi/simulator/services/zoneminder/constants.py
@@ -0,0 +1,4 @@
+class ZmSimConstants:
+
+ TIMEZONE_NAME = 'America/Chicago'
+
diff --git a/src/hi/simulator/services/zoneminder/sim_models.py b/src/hi/simulator/services/zoneminder/sim_models.py
index f4f4b044..2d551c39 100644
--- a/src/hi/simulator/services/zoneminder/sim_models.py
+++ b/src/hi/simulator/services/zoneminder/sim_models.py
@@ -8,6 +8,7 @@ from hi.simulator.base_models import SimEntityFields, SimState, SimEntityDefinit
from hi.simulator.enums import SimEntityType, SimStateType
from hi.simulator.sim_entity import SimEntity
+from .constants import ZmSimConstants
from .enums import ZmMonitorFunction, ZmRunStateType
@@ -34,7 +35,7 @@ class ZmServerRunState( SimState ):
@dataclass( frozen = True )
-class ZmServerSimEntity:
+class ZmSimServer:
""" Wrapper to encapsulate ZmServer-specific accessors """
sim_entity : SimEntity
@@ -99,7 +100,7 @@ class ZmMonitorSimEntityFields( SimEntityFields ):
@dataclass( frozen = True )
-class ZmMonitorSimEntity:
+class ZmSimMonitor:
""" Wrapper to encapsulate ZmMonitor-specific accessors """
sim_entity : SimEntity
@@ -107,6 +108,26 @@ class ZmMonitorSimEntity:
@property
def monitor_id(self):
return self.sim_entity.sim_entity_fields.monitor_id
+
+ @property
+ def width(self):
+ return self.sim_entity.sim_entity_fields.width
+
+ @property
+ def height(self):
+ return self.sim_entity.sim_entity_fields.height
+
+ @property
+ def orientation(self):
+ return self.sim_entity.sim_entity_fields.orientation
+
+ @property
+ def motion_sim_state(self) -> SimState:
+ for sim_state in self.sim_entity.sim_state_list:
+ if isinstance( sim_state, ZmMonitorMotionState ):
+ return sim_state
+ continue
+ raise ValueError( f'No motion sim state for ZM monitor {self.sim_entity}' )
def to_api_dict(self):
fields = self.sim_entity.sim_entity_fields
@@ -256,40 +277,74 @@ class ZmMonitorMotionState( SimState ):
@dataclass
-class ZmEvent:
+class ZmSimEvent:
- zm_monitor : ZmMonitorSimEntityFields
+ zm_sim_monitor : ZmSimMonitor
event_id : int
start_datetime : datetime
end_datetime : datetime
name : str
- cause : str
- length_secs : float
- total_frames : int
- alarm_frames : int
- total_score : int
- average_score : int
- max_score : int
-
+ cause : str = 'Simulator',
+ length_secs : float = 0.0
+ total_frames : int = 0
+ alarm_frames : int = 0
+ total_score : int = 0
+ average_score : int = 0
+ max_score : int = 0
+
+ @property
+ def is_active(self):
+ return bool( self.end_datetime is None )
+
+ def update_score_properties( self ):
+ if self.end_datetime:
+ now_datetime = self.end_datetime
+ else:
+ now_datetime = datetimeproxy.now()
+
+ duration_timedelta = now_datetime - self.start_datetime
+
+ self.length_secs = float( duration_timedelta.seconds )
+
+ # TODO: Setting these somewhat randomly and with specicic event
+ # characteristics. Only will need to change this if we need
+ # finer-grained control over the simulation.
+
+ frame_per_second = 5
+ self.total_frames = int( duration_timedelta.seconds * frame_per_second )
+ self.alarm_frames = int( self.total_frames / 2 )
+ self.total_score = int( self.alarm_frames * 10 )
+ self.average_score = int( self.alarm_frames * 5 )
+ self.max_score = int( self.alarm_frames * 20 )
+ return
+
def to_api_dict(self):
- start_datetime_str = self.start_datetime.strftime('%Y-%m-%d %H:%M:%S')
+ tz_adjusted_start_datetime = datetimeproxy.change_timezone(
+ original_datetime = self.start_datetime,
+ new_tzname = ZmSimConstants.TIMEZONE_NAME,
+ )
+ start_datetime_str = tz_adjusted_start_datetime.strftime('%Y-%m-%d %H:%M:%S')
if self.end_datetime:
- end_datetime_str = self.end_datetime.strftime('%Y-%m-%d %H:%M:%S')
+ tz_adjusted_end_datetime = datetimeproxy.change_timezone(
+ original_datetime = self.end_datetime,
+ new_tzname = ZmSimConstants.TIMEZONE_NAME,
+ )
+ end_datetime_str = tz_adjusted_end_datetime.strftime('%Y-%m-%d %H:%M:%S')
else:
end_datetime_str = None
date_str = datetimeproxy.to_date_str( self.start_datetime )
return {
'Event': {
'Id': str(self.event_id),
- 'MonitorId': str(self.zm_monitor.monitor_id),
+ 'MonitorId': str(self.zm_sim_monitor.monitor_id),
'StorageId': '0',
'SecondaryStorageId': '0',
'Name': 'Event- 11091',
'Cause': 'Forced Web',
'StartTime': start_datetime_str,
'EndTime': end_datetime_str,
- 'Width': self.zm_monitor.width,
- 'Height': self.zm_monitor.height,
+ 'Width': self.zm_sim_monitor.width,
+ 'Height': self.zm_sim_monitor.height,
'Length': f'{self.length_secs:.2}',
'Frames': str(self.total_frames),
'AlarmFrames': str(self.alarm_frames),
@@ -306,12 +361,12 @@ class ZmEvent:
'Executed': '0',
'Notes': f'{self.cause}: ',
'StateId': '2',
- 'Orientation': self.zm_monitor.orientation,
+ 'Orientation': self.zm_sim_monitor.orientation,
'DiskSpace': '27303821',
'Scheme': 'Medium',
'Locked': False,
'MaxScoreFrameId': '577976',
- 'FileSystemPath': f'/var/cache/zoneminder/events/{self.zm_monitor.monitor_id}/{date_str}/{self.event_id}',
+ 'FileSystemPath': f'/var/cache/zoneminder/events/{self.zm_sim_monitor.monitor_id}/{date_str}/{self.event_id}',
}
}
diff --git a/src/hi/simulator/services/zoneminder/simulator.py b/src/hi/simulator/services/zoneminder/simulator.py
index 37e8ca5c..047836f3 100644
--- a/src/hi/simulator/services/zoneminder/simulator.py
+++ b/src/hi/simulator/services/zoneminder/simulator.py
@@ -1,6 +1,6 @@
from typing import List, Set
-from hi.simulator.base_models import SimEntityDefinition, SimEntityFields
+from hi.simulator.base_models import SimEntityDefinition, SimEntityFields, SimState
from hi.simulator.exceptions import SimEntityValidationError
from hi.simulator.simulator import Simulator
from hi.simulator.sim_entity import SimEntity
@@ -8,17 +8,19 @@ from hi.simulator.sim_entity import SimEntity
from .enums import ZmMonitorFunction, ZmRunStateType
from .sim_models import (
ZONEMINDER_SIM_ENTITY_DEFINITION_LIST,
+ ZmSimMonitor,
ZmMonitorSimEntityFields,
+ ZmMonitorMotionState,
+ ZmSimServer,
ZmServerSimEntityFields,
- ZmMonitorSimEntity,
- ZmServerSimEntity,
ZmSimRunState,
ZmSimRunStateDefinition,
)
+from .zm_event_manager import ZmSimEventManager
class ZoneMinderSimulator( Simulator ):
-
+
@property
def id(self):
return 'zm'
@@ -27,14 +29,14 @@ class ZoneMinderSimulator( Simulator ):
def label(self) -> str:
return 'ZoneMinder'
- def get_zm_monitor_sim_entity_list( self ) -> List[ ZmMonitorSimEntity ]:
- return [ ZmMonitorSimEntity( sim_entity = x ) for x in self.sim_entities
+ 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 get_zm_server_sim_entity( self ) -> ZmServerSimEntity:
+ 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 ZmServerSimEntity( sim_entity = sim_entity )
+ return ZmSimServer( sim_entity = sim_entity )
continue
raise ValueError( 'No ZM server entity has been created.' )
@@ -142,3 +144,22 @@ class ZoneMinderSimulator( Simulator ):
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
+
diff --git a/src/hi/simulator/services/zoneminder/zm_event_history.py b/src/hi/simulator/services/zoneminder/zm_event_history.py
new file mode 100644
index 00000000..d3526678
--- /dev/null
+++ b/src/hi/simulator/services/zoneminder/zm_event_history.py
@@ -0,0 +1,61 @@
+from collections import deque
+from datetime import datetime
+from typing import List
+
+import hi.apps.common.datetimeproxy as datetimeproxy
+
+from .sim_models import ZmSimEvent, ZmSimMonitor
+
+
+class ZmSimEventHistory:
+
+ event_counter = 0
+
+ def __init__( self, zm_sim_monitor : ZmSimMonitor, max_events: int = 500 ):
+ self._zm_sim_monitor = zm_sim_monitor
+ self._zm_sim_events = deque( maxlen = max_events )
+ return
+
+ def __len__(self):
+ return len(self._zm_sim_events)
+
+ def add_motion_value( self, motion_value : bool ) -> ZmSimEvent:
+
+ if ( len(self) == 0 ):
+ if motion_value:
+ return self.add_zm_sim_event()
+ else:
+ return None
+
+ latest_zm_sim_event = self._zm_sim_events[-1]
+ if motion_value:
+ if latest_zm_sim_event.is_active:
+ return latest_zm_sim_event
+ else:
+ return self.add_zm_sim_event()
+
+ latest_zm_sim_event.end_datetime = datetimeproxy.now()
+ return latest_zm_sim_event
+
+ def add_zm_sim_event( self ) -> ZmSimEvent:
+ self.event_counter += 1
+ zm_sim_event = ZmSimEvent(
+ zm_sim_monitor = self._zm_sim_monitor,
+ event_id = self.event_counter,
+ start_datetime = datetimeproxy.now(),
+ end_datetime = None,
+ name = f'Event {self.event_counter}',
+ )
+ self._zm_sim_events.append( zm_sim_event )
+ return zm_sim_event
+
+ def close_zm_sim_event( self, zm_sim_event: ZmSimEvent ):
+ zm_sim_event.end_datetime = datetimeproxy.now()
+ zm_sim_event.update_score_properties()
+ return
+
+ def get_events_by_start_datetime( self, start_datetime : datetime ) -> List[ ZmSimEvent ]:
+ # N.B.: This could be made more efficient by looping backwards over
+ # list and stopping when a non-matching item is found.
+
+ return [ x for x in self._zm_sim_events if x.start_datetime >= start_datetime]
diff --git a/src/hi/simulator/services/zoneminder/zm_event_manager.py b/src/hi/simulator/services/zoneminder/zm_event_manager.py
new file mode 100644
index 00000000..2c4eab38
--- /dev/null
+++ b/src/hi/simulator/services/zoneminder/zm_event_manager.py
@@ -0,0 +1,47 @@
+from datetime import datetime
+import threading
+from typing import Dict, List
+
+from hi.apps.common.singleton import Singleton
+
+from .sim_models import ZmSimEvent, ZmSimMonitor
+from .zm_event_history import ZmSimEventHistory
+
+
+class ZmSimEventManager( Singleton ):
+
+ def __init_singleton__( self ):
+ self._zm_sim_events_map : Dict[ int, ZmSimEventHistory ] = dict()
+ self._data_lock = threading.Lock()
+ return
+
+ def add_motion_value( self,
+ zm_sim_monitor : ZmSimMonitor,
+ motion_value : bool ):
+ self._data_lock.acquire()
+ try:
+ monitor_id = zm_sim_monitor.monitor_id
+ if monitor_id not in self._zm_sim_events_map:
+ self._zm_sim_events_map[monitor_id] = ZmSimEventHistory(
+ zm_sim_monitor = zm_sim_monitor,
+ )
+ self._zm_sim_events_map[monitor_id].add_motion_value( motion_value = motion_value )
+ finally:
+ self._data_lock.release()
+ return
+
+ def get_events_by_start_datetime( self, start_datetime : datetime ) -> List[ ZmSimEvent ]:
+ zm_sim_event_list = list()
+ for zm_event_history in self._zm_sim_events_map.values():
+ event_list = zm_event_history.get_events_by_start_datetime( start_datetime = start_datetime )
+ zm_sim_event_list.extend( event_list )
+ continue
+ self._update_zm_sim_events( zm_sim_event_list = zm_sim_event_list )
+ return zm_sim_event_list
+
+ def _update_zm_sim_events( self, zm_sim_event_list : List[ ZmSimEvent ] ):
+ for zm_sim_event in zm_sim_event_list:
+ if zm_sim_event.is_active:
+ zm_sim_event.update_score_properties()
+ continue
+ return
diff --git a/src/hi/simulator/sim_entity.py b/src/hi/simulator/sim_entity.py
index cf46315d..e3cc7232 100644
--- a/src/hi/simulator/sim_entity.py
+++ b/src/hi/simulator/sim_entity.py
@@ -63,6 +63,6 @@ class SimEntity:
for sim_state_id, self_sim_state in self._sim_state_map.items():
other_sim_state = other_sim_entity._sim_state_map.get( sim_state_id )
if other_sim_state:
- self_sim_state.value = other_sim_state.value
+ self_sim_state.copy_value( other_sim_state )
continue
return
diff --git a/src/hi/simulator/simulator.py b/src/hi/simulator/simulator.py
index 1131d26b..9cbf03f9 100644
--- a/src/hi/simulator/simulator.py
+++ b/src/hi/simulator/simulator.py
@@ -43,6 +43,11 @@ class Simulator( Singleton ):
sim_entity_list.sort( key = lambda item : item.name )
return sim_entity_list
+ def get_sim_entity_by_id( self, sim_entity_id : int ) -> SimEntity:
+ if sim_entity_id not in self._sim_entity_map:
+ raise KeyError( f'No simulator ewntity found with id = {sim_entity_id}' )
+ return self._sim_entity_map.get( sim_entity_id )
+
def initialize( self ):
"""
The SimulatorManager stores, hydrates and defines the set of existing
@@ -86,7 +91,7 @@ class Simulator( Singleton ):
sim_entity_id : int,
sim_state_id : str,
value_str : str ) -> SimState:
- sim_entity = self._sim_entity_map[sim_entity_id]
+ sim_entity = self.get_sim_entity_by_id( sim_entity_id = sim_entity_id )
return sim_entity.set_sim_state(
sim_state_id = sim_state_id,
value_str = value_str,