simo 3.0.5__py3-none-any.whl → 3.1.1__py3-none-any.whl

simo/automation/gateways.py

@@ -216,6 +216,7 @@ class GatesHandler:
 class AutomationsGatewayHandler(GatesHandler, BaseObjectCommandsGatewayHandler):
     name = "Automation"
     config_form = BaseGatewayForm
+    auto_create = True
     info = "Provides various types of automation capabilities"
 
     running_scripts = {}

simo/core/api.py

@@ -7,6 +7,7 @@ from django.utils.translation import gettext_lazy as _
 from django.utils import timezone
 from django.http import HttpResponse, Http404
 from simo.core.utils.helpers import get_self_ip, search_queryset
+from simo.core.middleware import introduce_instance
 from rest_framework import status
 from actstream.models import Action
 from rest_framework.pagination import PageNumberPagination
@@ -41,6 +42,7 @@ class InstanceMixin:
         ).last()
         if not self.instance:
             raise Http404()
+        introduce_instance(self.instance)
         return super().dispatch(request, *args, **kwargs)
 
     def get_serializer_context(self):
@@ -140,7 +142,8 @@ class ZoneViewSet(InstanceMixin, viewsets.ModelViewSet):
             )
         for i, id in enumerate(request_data.get('zones')):
             zones[str(id)].order = i
-        Zone.objects.bulk_update([z for id, z in zones.items()], fields=['order'])
+        for i, zone in zones.items():
+            zone.save()
         return RESTResponse({'status': 'success'})
 
 

simo/core/db_backend/base.py

@@ -1,21 +1,19 @@
-import random, time
 from django.contrib.gis.db.backends.postgis.base import (
     DatabaseWrapper as PostGisPsycopg2DatabaseWrapper
 )
-from django.db import close_old_connections, connection as db_connection
+from django.db.utils import OperationalError, InterfaceError
 from django.utils.asyncio import async_unsafe
-from django.db.utils import InterfaceError
-from django.conf import settings
 
 
 class DatabaseWrapper(PostGisPsycopg2DatabaseWrapper):
-
     @async_unsafe
     def create_cursor(self, name=None):
-        if not self.is_usable():
-            close_old_connections()
-            db_connection.connect()
-        return super().create_cursor(name=name)
-
+        try:
+            return super().create_cursor(name=name)
+        except (InterfaceError, OperationalError):
+            # Heal this very connection
+            self.close()
+            self.connect()
+            return super().create_cursor(name=name)
 
 

simo/core/events.py

@@ -52,8 +52,8 @@ class ObjectChangeEvent(ObjMqttAnnouncement):
         self.data.update(**kwargs)
 
     def get_topic(self):
-        return f"{self.TOPIC}/{self.instance.id if self.instance else 'global'}/" \
-               f"{type(self.obj).__name__}-{self.data['obj_pk']}"
+        return f"{self.TOPIC}/{self.instance.uid if self.instance else 'global'}/" \
+               f"{type(self.obj).__name__}/{self.data['obj_pk']}"
 
     def publish(self, retain=True):
         return super().publish(retain=retain)
@@ -91,6 +91,33 @@ def get_event_obj(payload, model_class=None, gateway=None):
     return obj
 
 
+def dirty_fields_to_current_values(instance, dirty_fields):
+    """Return a mapping of changed field names to the instance's current values.
+
+    - Avoids extra DB hits by reading values from the in-memory instance.
+    - For ForeignKey fields, emits the underlying ``<field>_id`` when available
+      to keep the payload JSON-serializable and consistent.
+    """
+    if not dirty_fields:
+        return {}
+
+    current = {}
+    for field_name in dirty_fields.keys():
+        try:
+            model_field = instance._meta.get_field(field_name)
+            # Many-to-many changes are not handled here (not part of default dirty_fields)
+            if getattr(model_field, 'many_to_many', False):
+                continue
+            if getattr(model_field, 'is_relation', False) and hasattr(instance, f"{field_name}_id"):
+                current[field_name] = getattr(instance, f"{field_name}_id")
+            else:
+                current[field_name] = getattr(instance, field_name, None)
+        except Exception:
+            # Field might not be a real model field (unlikely); fallback to attribute
+            current[field_name] = getattr(instance, field_name, None)
+    return current
+
+
 class OnChangeMixin:
 
     _on_change_function = None
@@ -164,4 +191,4 @@ class OnChangeMixin:
             self._mqtt_client.disconnect()
             self._mqtt_client.loop_stop()
             self._mqtt_client = None
-            self._on_change_function = None
+            self._on_change_function = None

simo/core/gateways.py

@@ -14,6 +14,10 @@ from simo.core.loggers import get_gw_logger
 
 
 class BaseGatewayHandler(ABC):
+    # Whether core should auto-create a Gateway row for this handler
+    # at hub startup (via on_http_start). Opt-in to avoid noisy defaults
+    # and side effects for handlers that require credentials/hardware.
+    auto_create = False
 
     @property
     @abstractmethod
@@ -134,4 +138,3 @@ class BaseObjectCommandsGatewayHandler(BaseGatewayHandler):
             except Exception as e:
                 self.logger.error(e, exc_info=True)
 
-

simo/core/management/_hub_template/hub/nginx.conf

@@ -63,6 +63,17 @@ server {
         proxy_send_timeout 3600s;
     }
 
+    # MQTT over WebSockets (WSS)
+    location ^~ /mqtt/ {
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "Upgrade";
+        proxy_set_header Host $host;
+        proxy_read_timeout 600s;
+        proxy_send_timeout 600s;
+        proxy_pass http://127.0.0.1:8083/;
+    }
+
 
     location / {
         include proxy_params;

simo/core/management/_hub_template/hub/supervisor.conf

@@ -78,6 +78,37 @@ killasgroup=true
 stopsignal=INT
 
 
+[program:simo-app-mqtt]
+directory={{ project_dir }}/hub/
+command={{ venv_path }}/python manage.py run_app_mqtt_control
+process_name=%(program_name)s
+user=root
+stdout_logfile=/var/log/simo/app_mqtt.log
+stdout_logfile_maxbytes=1MB
+stdout_logfile_backups=3
+redirect_stderr=true
+autostart=true
+autorestart=true
+stopwaitsecs=15
+killasgroup=true
+stopsignal=INT
+
+[program:simo-app-mqtt-fanout]
+directory={{ project_dir }}/hub/
+command={{ venv_path }}/python manage.py run_app_mqtt_fanout
+process_name=%(program_name)s
+user=root
+stdout_logfile=/var/log/simo/app_mqtt_fanout.log
+stdout_logfile_maxbytes=1MB
+stdout_logfile_backups=3
+redirect_stderr=true
+autostart=true
+autorestart=true
+stopwaitsecs=15
+killasgroup=true
+stopsignal=INT
+
+
 [program:simo-celery-beat]
 directory={{ project_dir }}/hub/
 command={{ venv_path }}/celery -A celeryc.celery_app beat -l info --pidfile="/var/run/celerybeat.pid"

simo/core/management/commands/on_http_start.py

@@ -10,6 +10,7 @@ from django.apps import apps
 from crontab import CronTab
 from django.conf import settings
 from django.template.loader import render_to_string
+from django.db import transaction
 
 
 def prepare_mosquitto():
@@ -84,6 +85,70 @@ class Command(BaseCommand):
         from simo.core.tasks import maybe_update_to_latest
         maybe_update_to_latest.delay()
         update_auto_update()
+        # Auto-create Gateway rows for handlers that opted in
+        try:
+            from simo.core.models import Gateway
+            from simo.core.utils.type_constants import GATEWAYS_MAP
+            created_any = False
+            for uid, handler_cls in GATEWAYS_MAP.items():
+                if getattr(handler_cls, 'auto_create', False):
+                    # Build default config from handler's config_form
+                    config_defaults = {}
+                    try:
+                        form_cls = getattr(handler_cls, 'config_form', None)
+                        if form_cls is not None:
+                            tmp_instance = Gateway(type=uid)
+                            form = form_cls(instance=tmp_instance)
+                            for fname, field in getattr(form, 'fields', {}).items():
+                                if fname in ('log',):
+                                    continue
+                                init = getattr(field, 'initial', None)
+                                if init is None:
+                                    continue
+                                # Normalize potential Model/QuerySet values to pks
+                                try:
+                                    import json as _json
+                                    def _norm(v):
+                                        try:
+                                            return _json.loads(_json.dumps(v))
+                                        except Exception:
+                                            pass
+                                        # Model instance
+                                        if hasattr(v, 'pk'):
+                                            return v.pk
+                                        # QuerySet or iterable of models
+                                        try:
+                                            from django.db.models.query import QuerySet as _QS
+                                            if isinstance(v, _QS):
+                                                return [obj.pk for obj in v]
+                                        except Exception:
+                                            pass
+                                        if isinstance(v, (list, tuple, set)):
+                                            return [_norm(x) for x in v]
+                                        return v
+                                    config_defaults[fname] = _norm(init)
+                                except Exception:
+                                    # Best-effort; skip if cannot serialize
+                                    continue
+                    except Exception:
+                        # If we cannot introspect defaults, fall back to empty config
+                        pass
+
+                    obj, created = Gateway.objects.get_or_create(
+                        type=uid, defaults={'config': config_defaults}
+                    )
+                    if created:
+                        created_any = True
+                        print(f"Auto-created gateway: {handler_cls.name} ({uid})")
+                        try:
+                            obj.start()
+                        except Exception:
+                            print(traceback.format_exc(), file=sys.stderr)
+            if created_any:
+                pass
+        except Exception:
+            # Do not fail startup on gateway auto-create issues
+            print(traceback.format_exc(), file=sys.stderr)
         for name, app in apps.app_configs.items():
             if name in (
                 'auth', 'admin', 'contenttypes', 'sessions', 'messages',
@@ -96,4 +161,3 @@ class Command(BaseCommand):
                 continue
             except:
                 print(traceback.format_exc(), file=sys.stderr)
-

simo/core/management/commands/republish_mqtt_state.py

@@ -0,0 +1,60 @@
+from django.core.management.base import BaseCommand
+from django.utils import timezone
+
+from simo.core.events import ObjectChangeEvent
+from simo.core.models import Instance, Zone, Category, Component
+from simo.users.models import InstanceUser
+
+
+class Command(BaseCommand):
+    help = "Republish retained MQTT state for zones, categories, components, and instance users."
+
+    def add_arguments(self, parser):
+        parser.add_argument('--instance', type=int, help='Instance ID to republish (default: all)')
+
+    def handle(self, *args, **options):
+        instance_id = options.get('instance')
+        instances = Instance.objects.filter(is_active=True)
+        if instance_id:
+            instances = instances.filter(id=instance_id)
+
+        count = 0
+        for inst in instances:
+            # Zones
+            for zone in Zone.objects.filter(instance=inst):
+                ObjectChangeEvent(inst, zone, name=zone.name).publish()
+                count += 1
+
+            # Categories
+            for cat in Category.objects.filter(instance=inst):
+                ObjectChangeEvent(
+                    inst, cat, name=cat.name, last_modified=cat.last_modified
+                ).publish()
+                count += 1
+
+            # Components
+            for comp in Component.objects.filter(zone__instance=inst):
+                data = {
+                    'value': comp.value,
+                    'last_change': comp.last_change,
+                    'arm_status': comp.arm_status,
+                    'battery_level': comp.battery_level,
+                    'alive': comp.alive,
+                    'meta': comp.meta,
+                }
+                ObjectChangeEvent(inst, comp, **data).publish()
+                count += 1
+
+            # Instance users (presence and phone charging)
+            for iu in InstanceUser.objects.filter(instance=inst, is_active=True):
+                ObjectChangeEvent(
+                    inst,
+                    iu,
+                    at_home=iu.at_home,
+                    last_seen=iu.last_seen,
+                    phone_on_charge=iu.phone_on_charge,
+                ).publish()
+                count += 1
+
+        self.stdout.write(self.style.SUCCESS(f"Republished {count} retained messages."))
+

simo/core/management/commands/run_app_mqtt_control.py

@@ -0,0 +1,129 @@
+import json
+import sys
+import traceback
+import paho.mqtt.client as mqtt
+from django.core.management.base import BaseCommand
+from django.conf import settings
+
+from simo.users.models import User, InstanceUser, ComponentPermission
+from simo.users.utils import introduce_user
+from simo.core.models import Component
+
+
+CONTROL_PREFIX = 'SIMO/user'
+
+
+class Command(BaseCommand):
+    help = 'Run MQTT control bridge to execute component controller methods from app MQTT requests.'
+
+    def handle(self, *args, **options):
+        client = mqtt.Client()
+        client.username_pw_set('root', settings.SECRET_KEY)
+        client.on_connect = self.on_connect
+        client.on_message = self.on_message
+        client.connect(host=settings.MQTT_HOST, port=settings.MQTT_PORT)
+        try:
+            while True:
+                client.loop()
+        finally:
+            try:
+                client.disconnect()
+            except Exception:
+                pass
+
+    def on_connect(self, client, userdata, flags, rc):
+        # SIMO/user/+/control/#
+        client.subscribe(f'{CONTROL_PREFIX}/+/control/#')
+
+    def on_message(self, client, userdata, msg):
+        try:
+            parts = msg.topic.split('/')
+            # SIMO/user/<user-id>/control/<instance-uid>/Component/<component-id>
+            if len(parts) < 7 or parts[0] != 'SIMO' or parts[1] != 'user' or parts[3] != 'control':
+                return
+            user_id = int(parts[2])
+            instance_uid = parts[4]
+            if parts[5] != 'Component':
+                return
+            try:
+                component_id = int(parts[6])
+            except Exception:
+                return
+
+            # Resolve user and permission
+            user = User.objects.filter(id=user_id).first()
+            if not user or not user.is_active:
+                return
+            if not user.is_master:
+                # Must be active on instance
+                if not InstanceUser.objects.filter(
+                    user=user, instance__uid=instance_uid, is_active=True
+                ).exists():
+                    return
+                # Must have write permission on the component
+                has_write = ComponentPermission.objects.filter(
+                    role__in=user.roles.all(),
+                    component_id=component_id,
+                    component__zone__instance__uid=instance_uid,
+                    write=True,
+                ).exists()
+                if not has_write:
+                    return
+
+            # Execute controller method
+            component = Component.objects.filter(
+                id=component_id, zone__instance__uid=instance_uid
+            ).first()
+            if not component:
+                return
+
+            introduce_user(user)
+            payload = json.loads(msg.payload or '{}')
+            request_id = payload.get('request_id')
+            sub_id = payload.get('subcomponent_id')
+            method = payload.get('method')
+            args = payload.get('args', [])
+            kwargs = payload.get('kwargs', {})
+            if method in (None, 'id', 'secret') or str(method).startswith('_'):
+                return
+
+            # Choose target component (main or subcomponent)
+            target = component
+            if sub_id:
+                try:
+                    target = component.slaves.get(pk=sub_id)
+                except Exception:
+                    return
+
+            # Prepare controller and call
+            target.prepare_controller()
+            if not hasattr(target, method):
+                self.respond(client, user_id, request_id, ok=False, error=f'Method {method} not found')
+                return
+            call = getattr(target, method)
+            try:
+                if isinstance(args, list) and isinstance(kwargs, dict):
+                    result = call(*args, **kwargs)
+                elif isinstance(args, list):
+                    result = call(*args)
+                elif isinstance(kwargs, dict):
+                    result = call(**kwargs)
+                else:
+                    result = call()
+                self.respond(client, user_id, request_id, ok=True, result=result)
+            except Exception:
+                self.respond(client, user_id, request_id, ok=False, error=''.join(traceback.format_exception(*sys.exc_info())))
+        except Exception:
+            # Never crash the consumer
+            pass
+
+    def respond(self, client, user_id, request_id, ok=True, result=None, error=None):
+        if not request_id:
+            return
+        topic = f'{CONTROL_PREFIX}/{user_id}/control-resp/{request_id}'
+        payload = {'ok': ok}
+        if ok:
+            payload['result'] = result
+        else:
+            payload['error'] = error
+        client.publish(topic, json.dumps(payload), qos=0, retain=False)

simo/core/management/commands/run_app_mqtt_fanout.py

@@ -0,0 +1,96 @@
+import json
+import sys
+import traceback
+import paho.mqtt.client as mqtt
+from django.core.management.base import BaseCommand
+from django.conf import settings
+from simo.core.events import get_event_obj
+from simo.core.models import Component, Zone, Category
+from simo.users.models import User, InstanceUser, ComponentPermission
+
+
+OBJ_STATE_PREFIX = 'SIMO/obj-state'
+FEED_PREFIX = 'SIMO/user'
+
+
+class Command(BaseCommand):
+    help = 'Authorizing fanout for app feeds: replicate internal obj-state to per-user feed topics.'
+
+    def handle(self, *args, **options):
+        self.client = mqtt.Client()
+        self.client.username_pw_set('root', settings.SECRET_KEY)
+        self.client.on_connect = self.on_connect
+        self.client.on_message = self.on_message
+        self.client.connect(host=settings.MQTT_HOST, port=settings.MQTT_PORT)
+        try:
+            while True:
+                self.client.loop()
+        finally:
+            try:
+                self.client.disconnect()
+            except Exception:
+                pass
+
+    def on_connect(self, client, userdata, flags, rc):
+        client.subscribe(f'{OBJ_STATE_PREFIX}/#')
+
+    def on_message(self, client, userdata, msg):
+        try:
+            topic_parts = msg.topic.split('/')
+            # SIMO/obj-state/<instance-uid>/<Model>/<id>
+            if len(topic_parts) < 5 or topic_parts[0] != 'SIMO' or topic_parts[1] != 'obj-state':
+                return
+            instance_uid = topic_parts[2]
+            model_name = topic_parts[3]
+            obj_id = topic_parts[4]
+
+            # Only forward instance-scoped objects that the app cares about
+            payload = json.loads(msg.payload or '{}')
+
+            # Resolve object if needed (mainly for Components to do permission checks)
+            target_obj = None
+            if model_name == 'Component':
+                target_obj = get_event_obj(payload, model_class=Component)
+                if not target_obj:
+                    return
+            elif model_name == 'Zone':
+                target_obj = get_event_obj(payload, model_class=Zone)
+            elif model_name == 'Category':
+                target_obj = get_event_obj(payload, model_class=Category)
+            elif model_name == 'InstanceUser':
+                # presence updates; no need to resolve explicitly
+                pass
+            else:
+                # Ignore other objects for feed
+                return
+
+            publish_to_users = set([
+                m.id for m in User.objects.filter(is_master=True) if m.is_active
+            ])
+            for iu in InstanceUser.objects.filter(
+                instance__uid=instance_uid, is_active=True
+            ).select_related('user', 'role'):
+                if iu.user.is_master:
+                    publish_to_users.add(iu.user.id)
+                    continue
+                if iu.role.is_superuser:
+                    publish_to_users.add(iu.user.id)
+                    continue
+                if model_name != 'Component':
+                    publish_to_users.add(iu.user.id)
+                    continue
+                if ComponentPermission.objects.filter(
+                    role=iu.role,
+                    component_id=target_obj.id,
+                    component__zone__instance__uid=instance_uid,
+                    read=True,
+                ).exists():
+                    publish_to_users.add(iu.user.id)
+                    continue
+
+            for user_id in publish_to_users:
+                feed_topic = f'{FEED_PREFIX}/{user_id}/feed/{instance_uid}/{model_name}/{obj_id}'
+                client.publish(feed_topic, msg.payload, qos=0, retain=True)
+        except Exception:
+            # Never crash the consumer
+            print('Fanout error:', ''.join(traceback.format_exception(*sys.exc_info())), file=sys.stderr)

simo/core/signal_receivers.py

@@ -136,26 +136,50 @@ def post_save_actions_dispatcher(sender, instance, created, **kwargs):
         action_type='management_event'
     )
 
+    # Announce Zone/Category changes over MQTT for mobile live updates
+    from .events import ObjectChangeEvent, dirty_fields_to_current_values
+    dirty_fields_prev = instance.get_dirty_fields()
+
+    def post_update():
+        if not dirty_fields_prev:
+            return
+
+        data = {}
+        # Provide minimal fields clients can use without re-fetching
+        if isinstance(instance, Zone):
+            data['name'] = instance.name
+        elif isinstance(instance, Category):
+            data['name'] = instance.name
+            data['last_modified'] = instance.last_modified
+
+        ObjectChangeEvent(
+            instance.instance, instance,
+            dirty_fields=dirty_fields_to_current_values(instance, dirty_fields_prev),
+            **data
+        ).publish()
+
+    transaction.on_commit(post_update)
+
 
 @receiver(post_save, sender=Component)
 @receiver(post_save, sender=Gateway)
 def post_save_change_events(sender, instance, created, **kwargs):
     target = instance
-    from .events import ObjectChangeEvent
-    dirty_fields = target.get_dirty_fields()
+    from .events import ObjectChangeEvent, dirty_fields_to_current_values
+    dirty_fields_prev = target.get_dirty_fields()
     for ignore_field in (
         'change_init_by', 'change_init_date', 'change_init_to', 'last_update'
     ):
-        dirty_fields.pop(ignore_field, None)
+        dirty_fields_prev.pop(ignore_field, None)
 
     def post_update():
-        if not dirty_fields:
+        if not dirty_fields_prev:
             return
 
         if type(target) == Gateway:
             ObjectChangeEvent(
                 None, target,
-                dirty_fields=dirty_fields,
+                dirty_fields=dirty_fields_to_current_values(target, dirty_fields_prev),
             ).publish()
         elif type(target) == Component:
             data = {}
@@ -166,7 +190,7 @@ def post_save_change_events(sender, instance, created, **kwargs):
                 data[field_name] = getattr(target, field_name, None)
             ObjectChangeEvent(
                 target.zone.instance, target,
-                dirty_fields=dirty_fields,
+                dirty_fields=dirty_fields_to_current_values(target, dirty_fields_prev),
                 actor=getattr(target, 'change_actor', None),
                 **data
             ).publish()
@@ -217,4 +241,4 @@ def delete_file_itself(sender, instance, *args, **kwargs):
     try:
         os.remove(instance.file.path)
     except:
-        pass
+        pass

simo/core/tasks.py

@@ -441,39 +441,7 @@ def restart_postgresql():
     proc.communicate()
 
 
-@celery_app.task
-def low_battery_notifications():
-    from simo.notifications.utils import notify_users
-    from simo.automation.helpers import be_or_not_to_be
-    for instance in Instance.objects.filter(is_active=True):
-        timezone.activate(instance.timezone)
-        hour = timezone.localtime().hour
-        if hour < 7:
-            continue
-        if hour > 21:
-            continue
-
-        introduce_instance(instance)
-        for comp in Component.objects.filter(
-            zone__instance=instance,
-            battery_level__isnull=False, battery_level__lt=20
-        ):
-            last_warning = comp.meta.get('last_battery_warning', 0)
-            notify = be_or_not_to_be(12 * 60 * 60, 72 * 60 * 60, last_warning)
-            if not notify:
-                continue
 
-            iusers = comp.zone.instance.instance_users.filter(
-                is_active=True, role__is_owner=True
-            )
-            if iusers:
-                notify_users(
-                    'warning',
-                    f"Low battery ({comp.battery_level}%) on {comp}",
-                    component=comp, instance_users=iusers
-                )
-            comp.meta['last_battery_warning'] = time.time()
-            comp.save()
 
 
 @celery_app.task
@@ -516,4 +484,3 @@ def setup_periodic_tasks(sender, **kwargs):
     sender.add_periodic_task(60 * 60, maybe_update_to_latest.s())
     sender.add_periodic_task(60, drop_fingerprints_learn.s())
     sender.add_periodic_task(60 * 60 * 24, restart_postgresql.s())
-    sender.add_periodic_task(60 * 60, low_battery_notifications.s())