simo 1.7.20__py3-none-any.whl → 2.0.0__py3-none-any.whl

simo/fleet/socket_consumers.py

@@ -2,23 +2,24 @@ import asyncio
 import json
 import logging
 import pytz
-import time
+import traceback
 import sys
+import zlib
+from django.db import transaction
 from logging.handlers import RotatingFileHandler
-from django.urls import reverse
 from django.utils import timezone
 from django.conf import settings
 import paho.mqtt.client as mqtt
 from channels.generic.websocket import AsyncWebsocketConsumer
 from asgiref.sync import sync_to_async
-from simo.core.utils.helpers import get_random_string
 from simo.core.utils.model_helpers import get_log_file_path
 from simo.core.events import GatewayObjectCommand, get_event_obj
-from simo.core.utils.helpers import get_self_ip
 from simo.core.models import Gateway, Instance, Component
 from simo.conf import dynamic_settings
+from simo.users.models import Fingerprint
 from .gateways import FleetGatewayHandler
 from .models import Colonel
+from .controllers import TTLock
 
 
 class FleetConsumer(AsyncWebsocketConsumer):
@@ -43,9 +44,8 @@ class FleetConsumer(AsyncWebsocketConsumer):
 
     async def connect(self):
 
-        print("Fleet socket connect! Headers: ", self.scope['headers'])
         headers = {
-            item[0].decode(): item[1].decode() for item in self.scope['headers']
+            item[0].decode().lower(): item[1].decode() for item in self.scope['headers']
         }
 
         instance_uid = headers.get('instance-uid')
@@ -81,44 +81,40 @@ class FleetConsumer(AsyncWebsocketConsumer):
         tz = await sync_to_async(get_tz, thread_sensitive=True)()
         timezone.activate(tz)
 
-        self.colonel, new = await sync_to_async(
-            Colonel.objects.update_or_create, thread_sensitive=True)(
-            uid=headers['colonel-uid'], defaults={
+        def get_colonel():
+            # looks like update_or_create doesn't work in socket/async environment.
+            defaults={
                 'instance': self.instance,
+                'name': headers.get('colonel-name'),
                 'type': headers['colonel-type'],
                 'firmware_version': headers['firmware-version'],
                 'last_seen': timezone.now()
             }
-        )
+            with transaction.atomic():
+                colonel, new = Colonel.objects.get_or_create(
+                    uid=headers['colonel-uid'], defaults=defaults
+                )
+                if not new:
+                    for key, val in defaults.items():
+                        setattr(colonel, key, val)
+                if new:
+                    colonel.enabled = True
+                colonel.save()
+
+            return colonel, new
+
+        self.colonel, new = await sync_to_async(
+            get_colonel, thread_sensitive=True
+        )()
 
-        print(f"Colonel {self.colonel} connected with headers: {headers}")
+        print(f"Colonel {self.colonel} connected!")
         if not self.colonel.enabled:
             print("Colonel %s drop, it's not enabled!" % str(self.colonel))
             await self.accept()
             return await self.close()
 
-        if not self.colonel.name and headers.get('colonel-name'):
-            def save_colonel_name(name):
-                self.colonel.name = name
-                self.colonel.save()
-
-            await sync_to_async(
-                save_colonel_name, thread_sensitive=True
-            )(headers['colonel-name'])
-
-        def set_colonel_authorized(val):
-            self.colonel.is_authorized = val
-            self.colonel.save()
-
-        if headers.get('instance-uid') == self.colonel.instance.uid \
-        and headers.get('instance-secret') == self.colonel.instance.fleet_options.secret_key:
-            await sync_to_async(
-                set_colonel_authorized, thread_sensitive=True
-            )(True)
-        else:
-            await sync_to_async(
-                set_colonel_authorized, thread_sensitive=True
-            )(False)
+        if headers.get('instance-uid') != self.colonel.instance.uid \
+        or headers.get('instance-secret') != self.colonel.instance.fleet_options.secret_key:
             print("NOT authorized!")
             return await self.close()
 
@@ -126,16 +122,27 @@ class FleetConsumer(AsyncWebsocketConsumer):
 
         await self.accept()
 
+        await self.log_colonel_connected()
+
+
+        def get_gateway():
+            return Gateway.objects.filter(
+                type=FleetGatewayHandler.uid
+            ).first()
+
+        self.gateway = await sync_to_async(
+            get_gateway, thread_sensitive=True
+        )()
+
         if self.colonel.firmware_auto_update \
             and self.colonel.minor_upgrade_available:
             await self.firmware_update(self.colonel.minor_upgrade_available)
         else:
             def on_mqtt_connect(mqtt_client, userdata, flags, rc):
-                for gateway in Gateway.objects.filter(
-                    type=FleetGatewayHandler.uid
-                ):
-                    command = GatewayObjectCommand(gateway)
-                    mqtt_client.subscribe(command.get_topic())
+                command = GatewayObjectCommand(self.gateway)
+                TOPIC = command.get_topic()
+                print("SUBSCRIBE TO TOPIC: ", TOPIC)
+                mqtt_client.subscribe(TOPIC)
 
             self.mqtt_client = mqtt.Client()
             self.mqtt_client.username_pw_set('root', settings.SECRET_KEY)
@@ -153,9 +160,11 @@ class FleetConsumer(AsyncWebsocketConsumer):
             # If we force this, vales get overridden by what is last
             # known by the hub
             # config = await self.get_config_data()
-            # await self.send(json.dumps({
+            # await self.send_data(
             #     'command': 'set_config', 'data': config
-            # }))
+            # })
+
+            await self.send_data({'command': 'hello'})
 
         asyncio.create_task(self.watch_connection())
 
@@ -174,11 +183,11 @@ class FleetConsumer(AsyncWebsocketConsumer):
             await asyncio.sleep(10)
             # Default pinging system sometimes get's lost somewhere,
             # therefore we use our own to ensure connection
-            await self.send(json.dumps({'command': 'ping'}))
+            await self.send_data({'command': 'ping'})
 
     async def firmware_update(self, to_version):
         print("Firmware update: ", str(self.colonel))
-        await self.send(json.dumps({'command': 'ota_update', 'version': to_version}))
+        await self.send_data({'command': 'ota_update', 'version': to_version})
 
     async def get_config_data(self):
         self.colonel = await sync_to_async(
@@ -207,67 +216,162 @@ class FleetConsumer(AsyncWebsocketConsumer):
         }
         config_data['settings'].update(instance_options)
         i2c_interfaces = await sync_to_async(list, thread_sensitive=True)(
-            self.colonel.i2c_interfaces.all()
+            self.colonel.i2c_interfaces.all().select_related(
+                'scl_pin', 'sda_pin'
+            )
         )
         for i2c_interface in i2c_interfaces:
             config_data['interfaces']['i2c-%d' % i2c_interface.no] = {
-                'scl': i2c_interface.scl_pin, 'sda': i2c_interface.sda_pin,
+                'scl': i2c_interface.scl_pin.no, 'sda': i2c_interface.sda_pin.no,
                 'freq': i2c_interface.freq
             }
         components = await sync_to_async(
             list, thread_sensitive=True
-        )(self.colonel.components.all())
-        for component in components:
+        )(self.colonel.components.all().prefetch_related('slaves'))
+
+        def get_comp_config(comp):
             try:
-                config_data['devices'][str(component.id)] = {
-                    'type': component.controller.uid.split('.')[-1],
-                    'config': component.config,
-                    'options': component.meta.get('options', {}),
-                    'val': component.controller._prepare_for_send(component.value)
+                comp_config = {
+                    'type': comp.controller.uid.split('.')[-1],
+                    'val': comp.controller._prepare_for_send(
+                        comp.value
+                    ),
+                    'config': comp.controller._get_colonel_config()
                 }
+                slaves = [
+                    s.id for s in comp.slaves.all()
+                    if s.config.get('colonel') == self.colonel.id
+                ]
+                if slaves:
+                    comp_config['slaves'] = slaves
+                if comp.meta.get('options'):
+                    comp_config['options'] = comp.meta['options']
+
+                config_data['devices'][str(comp.id)] = comp_config
             except:
+                print("Error preparing component config")
+                print(traceback.format_exc(), file=sys.stderr)
+            else:
+                return comp_config
+
+        for component in components:
+
+            comp_config = components = await sync_to_async(
+                get_comp_config, thread_sensitive=True
+            )(component)
+
+            if not comp_config:
                 continue
 
+            slaves = [
+                s.id for s in component.slaves.all()
+                if s.config.get('colonel') == self.colonel.id
+            ]
+            if slaves:
+                comp_config['slaves'] = slaves
+            if component.meta.get('options'):
+                comp_config['options'] = component.meta['options']
+
+            config_data['devices'][str(component.id)] = comp_config
+
+
         return config_data
 
     def on_mqtt_message(self, client, userdata, msg):
-        payload = json.loads(msg.payload)
-        colonel = get_event_obj(payload, Colonel)
-        if not colonel or colonel != self.colonel:
-            return
-        if payload.get('command') == 'update_firmware':
-            asyncio.run(self.firmware_update(payload['kwargs'].get('to_version')))
-        elif payload.get('command') == 'update_config':
-            async def send_config():
-                config = await self.get_config_data()
-                await self.send(json.dumps({
-                    'command': 'set_config', 'data': config
-                }))
-            asyncio.run(send_config())
-        elif 'set_val' in payload:
-            asyncio.run(self.send(json.dumps({
-                'command': 'set_val',
-                'id': payload.get('component_id'),
-                'val': payload['set_val']
-            })))
+        try:
+            payload = json.loads(msg.payload)
+
+            if 'bulk_send' in payload:
+                colonel_component_ids = [c['id'] for c in Component.objects.filter(
+                    config__colonel=self.colonel.id,
+                    gateway__in=Gateway.objects.filter(type=FleetGatewayHandler.uid),
+                    id__in=[int(id) for id in payload['bulk_send'].keys()]
+                ).values('id')]
+                bulk_send_data = []
+                for comp_id, value in payload['bulk_send'].items():
+                    if int(comp_id) not in colonel_component_ids:
+                        continue
+                    bulk_send_data.append({'id': int(comp_id), 'val': value})
+                if bulk_send_data:
+                    asyncio.run(self.send_data({
+                        'command': 'bulk_set',
+                        'values': bulk_send_data
+                    }))
+                return
+
+            obj = get_event_obj(payload)
+
+            if obj == self.colonel:
+                if payload.get('command') == 'update_firmware':
+                    asyncio.run(self.firmware_update(payload['to_version']))
+                elif payload.get('command') == 'update_config':
+                    async def send_config():
+                        config = await self.get_config_data()
+                        await self.send_data({
+                            'command': 'set_config', 'data': config
+                        }, compress=True)
+                    asyncio.run(send_config())
+                elif payload.get('command') == 'discover-ttlock':
+                    print("SEND discover-ttlock command!")
+                    asyncio.run(self.send_data({
+                        'command': 'discover-ttlock'
+                    }))
+                elif payload.get('command') == 'finalize':
+                    asyncio.run(self.send_data({
+                        'command': 'finalize',
+                        'data': payload.get('data', {})
+                    }))
+                else:
+                    asyncio.run(self.send_data(payload))
+
+            elif isinstance(obj, Component):
+                if int(obj.config.get('colonel')) != self.colonel.id:
+                    return
+                if 'set_val' in payload:
+                    asyncio.run(self.send_data({
+                        'command': 'set_val',
+                        'id': obj.id,
+                        'val': payload['set_val']
+                    }))
+                if 'update_options' in payload:
+                    asyncio.run(self.send_data({
+                        'command': 'update_options',
+                        'id': obj.id,
+                        'options': payload['options']
+                    }))
+
+        except Exception as e:
+            print(traceback.format_exc(), file=sys.stderr)
+
 
     async def receive(self, text_data=None, bytes_data=None):
         if text_data:
-            print("[%s]" % str(self.colonel), text_data)
+            print(f"{self.colonel}: {text_data}")
             data = json.loads(text_data)
             if 'get_config' in data:
                 config = await self.get_config_data()
-                await self.send(json.dumps({
+                print("Send config: ", config)
+                await self.send_data({
                     'command': 'set_config', 'data': config
-                }))
+                }, compress=True)
             elif 'comp' in data:
                 try:
+                    try:
+                        id=int(data['comp'])
+                    except:
+                        return
+
                     component = await sync_to_async(
                         Component.objects.get, thread_sensitive=True
-                    )(id=int(data['comp']))
+                    )(id=id)
 
                     if 'val' in data:
                         def receive_val(val):
+                            if data.get('actor'):
+                                fingerprint = Fingerprint.objects.filter(
+                                    value=f"ttlock-{component.id}-{data.get('actor')}",
+                                ).first()
+                                component.change_init_fingerprint = fingerprint
                             component.controller._receive_from_device(
                                 val, bool(data.get('alive'))
                             )
@@ -276,7 +380,6 @@ class FleetConsumer(AsyncWebsocketConsumer):
                         )(data['val'])
 
                     if 'options' in data:
-                        print("Received options update")
                         def receive_options(val):
                             component.meta['options'] = val
                             component.save()
@@ -284,8 +387,55 @@ class FleetConsumer(AsyncWebsocketConsumer):
                             receive_options, thread_sensitive=True
                         )(data['options'])
 
+                    if 'codes' in data and component.controller_uid == TTLock.uid:
+                        def save_codes(codes):
+                            component.meta['codes'] = codes
+                            for code in codes:
+                                Fingerprint.objects.get_or_create(
+                                    value=f"ttlock-{component.id}-code-{str(code)}",
+                                    defaults={'type': "TTLock code"}
+                                )
+                            component.save()
+                        await sync_to_async(
+                            save_codes, thread_sensitive=True
+                        )(data['codes'])
+                    if 'fingerprints' in data and component.controller_uid == TTLock.uid:
+                        def save_codes(codes):
+                            component.meta['fingerprints'] = codes
+                            for code in codes:
+                                Fingerprint.objects.get_or_create(
+                                    value=f"ttlock-{component.id}-finger-{str(code)}",
+                                    defaults={'type': "TTLock Fingerprint"}
+                                )
+                            component.save()
+                        await sync_to_async(
+                            save_codes, thread_sensitive=True
+                        )(data['fingerprints'])
+
                 except Exception as e:
-                    print(e)
+                    print(traceback.format_exc(), file=sys.stderr)
+
+            elif 'discover-ttlock' in data:
+                def process_discovery_result():
+                    self.gateway.refresh_from_db()
+                    if self.gateway.discovery.get('finished'):
+                        return Component.objects.filter(
+                            meta__finalization_data__temp_id=data['result']['id']
+                        ).first()
+                    try:
+                        self.gateway.process_discovery(data)
+                    except Exception as e:
+                        print(traceback.format_exc(), file=sys.stderr)
+                    self.gateway.finish_discovery()
+
+                finished_comp = await sync_to_async(
+                    process_discovery_result, thread_sensitive=True
+                )()
+                if finished_comp:
+                    await self.send_data({
+                        'command': 'finalize',
+                        'data': finished_comp.meta['finalization_data']
+                    })
 
         elif bytes_data:
             if not self.colonel_logger:
@@ -294,6 +444,11 @@ class FleetConsumer(AsyncWebsocketConsumer):
             for logline in bytes_data.decode(errors='replace').split('\n'):
                 self.colonel_logger.log(logging.INFO, logline)
 
+        await self.log_colonel_connected()
+
+
+    async def log_colonel_connected(self):
+
         def save_last_seen():
             self.colonel.socket_connected = True
             self.colonel.last_seen = timezone.now()
@@ -303,6 +458,14 @@ class FleetConsumer(AsyncWebsocketConsumer):
 
         await sync_to_async(save_last_seen, thread_sensitive=True)()
 
+    async def send_data(self, data, compress=False):
+        data = json.dumps(data)
+        if compress:
+            data = zlib.compress(data.encode())
+            await self.send(bytes_data=data)
+        else:
+            await self.send(data)
+
 
     async def start_logger(self):
         self.colonel_logger = logging.getLogger(

simo/fleet/utils.py

@@ -51,26 +51,19 @@ BASE_ESP32_GPIO_PINS = {
     39: {'output': False, 'adc': True},
 }
 
-GPIO_PINS = {'generic': {}, 'wESP32': {}, '4-relays': {}, 'ample-wall': {}}
+GPIO_PINS = {'generic': {}, '4-relays': {}, 'ample-wall': {}, 'game-changer': {}}
 
 for no, data in BASE_ESP32_GPIO_PINS.items():
     GPIO_PINS['generic'][no] = GPIO_PIN_DEFAULTS.copy()
 
-#wESP32 & ample-wall
+# ample-wall
 for no, data in BASE_ESP32_GPIO_PINS.items():
-    if no in (16, 17, 19, 21, 22, 23, 25, 26, 27):
-        # occupied by LAN
-        continue
-
-    if no == 2:
-        # onboard LED
-        continue
-
-    GPIO_PINS['wESP32'][no] = GPIO_PIN_DEFAULTS.copy()
-    GPIO_PINS['wESP32'][no].update(data)
+    if no in (4, 12, 13, 14, 15, 23, 32, 33, 34, 36, 39):
+        GPIO_PINS['ample-wall'][no] = GPIO_PIN_DEFAULTS.copy()
+        GPIO_PINS['ample-wall'][no].update(data)
 
-    GPIO_PINS['ample-wall'][no] = GPIO_PIN_DEFAULTS.copy()
-    GPIO_PINS['ample-wall'][no].update(data)
+        GPIO_PINS['game-changer'][no] = GPIO_PIN_DEFAULTS.copy()
+        GPIO_PINS['game-changer'][no].update(data)
 
 
 for no in range(101, 126):
@@ -87,6 +80,14 @@ for no in range(126, 133):
     }
 
 
+for no in range(101, 133):
+    GPIO_PINS['game-changer'][no] = {
+        'output': True, 'input': True, 'default_pull': 'LOW',
+        'native': False, 'adc': False,
+        'capacitive': False, 'note': ''
+    }
+
+
 #4-relays
 for no, data in BASE_ESP32_GPIO_PINS.items():
     if no == 12:
@@ -113,42 +114,3 @@ for no, data in BASE_ESP32_GPIO_PINS.items():
         GPIO_PINS['4-relays'][no]['note'] = 'Relay4'
     else:
         GPIO_PINS['4-relays'][no].update(data)
-
-
-def get_available_gpio_pins(colonel=None, filters=None, selected=None):
-    if not colonel:
-        return {no: GPIO_PIN_DEFAULTS for no in range(200)}
-    if not filters:
-        filters = {}
-    pins = {}
-    allow_occupied = filters.pop('allow_occupied', None)
-    for key, data in GPIO_PINS.get(colonel.type, {}).items():
-        if str(key) in colonel.occupied_pins and not allow_occupied:
-            if selected:
-                if int(key) != int(selected):
-                    continue
-            else:
-                continue
-        skip = False
-        for filter_param, filter_val in filters.items():
-            if data[filter_param] != filter_val:
-                skip = True
-        if skip:
-            continue
-        pins[key] = data
-    return pins
-
-
-def get_gpio_pins_choices(colonel=None, filters=None, selected=None):
-    choices = []
-    for key, data in get_available_gpio_pins(
-        colonel, filters, selected
-    ).items():
-        if key < 100:
-            name = 'GPIO%d' % key
-        else:
-            name = 'E-%d' % (key - 100)
-        if data.get('note'):
-            name += ' | %s' % data['note']
-        choices.append((key, name))
-    return choices

simo/fleet/views.py

@@ -1,32 +1,46 @@
-import os
-from django.http import FileResponse, HttpResponse, Http404
-from django.shortcuts import get_object_or_404
+from django.contrib.contenttypes.models import ContentType
+from django.http import HttpResponse, Http404
+from django.db.models import Q
 from dal import autocomplete
-from .models import Colonel, I2CInterface
-from .utils import get_gpio_pins_choices
+from simo.core.utils.helpers import search_queryset
+from .models import Colonel, ColonelPin, I2CInterface
 
 
 def colonels_ping(request):
     return HttpResponse('pong')
 
 
-class PinsSelectAutocomplete(autocomplete.Select2ListView):
+class PinsSelectAutocomplete(autocomplete.Select2QuerySetView):
 
-    def get_list(self):
+    def get_queryset(self):
         if not self.request.user.is_staff:
-            return []
+            return ColonelPin.objects.none()
 
         try:
-            esp_device = Colonel.objects.get(
+            colonel = Colonel.objects.get(
                 pk=self.forwarded.get("colonel")
             )
         except:
-            return []
+            return ColonelPin.objects.none()
+
+        qs = ColonelPin.objects.filter(colonel=colonel)
+
+        if self.forwarded.get('self'):
+            qs = qs.filter(
+                Q(occupied_by_id=None) | Q(
+                    id=int(self.forwarded['self'])
+                )
+            )
+        else:
+            qs = qs.filter(occupied_by_id=None)
+
+        if self.forwarded.get('filters'):
+            qs = qs.filter(**self.forwarded.get('filters'))
+
+        if self.q:
+            qs = search_queryset(qs, self.q, ('label', ))
 
-        return get_gpio_pins_choices(
-            esp_device, self.forwarded.get('filters'),
-            self.forwarded.get('self')
-        )
+        return qs
 
 
 class I2CInterfaceSelectAutocomplete(autocomplete.Select2ListView):