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

simo/fleet/models.py

@@ -3,12 +3,15 @@ from django.db import transaction
 from django.db import models
 from django.db.models.signals import post_save, pre_delete, post_delete
 from django.dispatch import receiver
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.contenttypes.fields import GenericForeignKey
 from dirtyfields import DirtyFieldsMixin
 from simo.core.models import Instance, Gateway, Component
 from simo.core.utils.helpers import get_random_string
 from simo.core.events import GatewayObjectCommand
 from .gateways import FleetGatewayHandler
-from .utils import get_gpio_pins_choices
+from .managers import ColonelsManager, ColonelPinsManager, I2CInterfacesManager
+from .utils import GPIO_PINS
 
 
 
@@ -49,10 +52,11 @@ class Colonel(DirtyFieldsMixin, models.Model):
     )
     name = models.CharField(max_length=100, blank=True)
     type = models.CharField(
-        max_length=20, default='wESP32',
+        max_length=20, default='ample-wall',
         choices=(
-            ('wESP32', 'wESP32'), ('4-relays', '4 Relays'),
-            ('ample-wall', "Ample Wall")
+            ('4-relays', "4 Relay"),
+            ('ample-wall', "Ample Wall"),
+            ('game-changer', "Game Changer"),
         )
     )
     firmware_version = models.CharField(
@@ -81,11 +85,11 @@ class Colonel(DirtyFieldsMixin, models.Model):
         default=False, help_text="Might cause unnecessary overhead. "
                                  "Better to leave this off if things are running smoothly."
     )
-    pwm_frequency = models.IntegerField(default=0, choices=(
+    pwm_frequency = models.IntegerField(default=1, choices=(
         (0, "3kHz"), (1, "22kHz")
     ), help_text="Affects Ample Wall dimmer PWM output (dimmer) frequency")
 
-    is_authorized = models.BooleanField(default=False, help_text="Temporrary field")
+    objects = ColonelsManager()
 
     def __str__(self):
         return self.name if self.name else self.uid
@@ -95,20 +99,13 @@ class Colonel(DirtyFieldsMixin, models.Model):
             for comp in self.components.all():
                 comp.alive = self.is_connected
                 comp.save()
-        is_new = self.pk is None
 
         if self.minor_upgrade_available and self.firmware_version == self.minor_upgrade_available:
             self.minor_upgrade_available = None
         if self.major_upgrade_available and self.firmware_version == self.major_upgrade_available:
             self.major_upgrade_available = None
 
-        obj = super().save(*args, **kwargs)
-        if is_new and self.type == 'ample-wall':
-            I2CInterface.objects.create(
-                colonel=self, name="Main", no=0, scl_pin=4, sda_pin=15,
-                freq=100000
-            )
-        return obj
+        return super().save(*args, **kwargs)
 
     @property
     def is_connected(self):
@@ -161,21 +158,28 @@ class Colonel(DirtyFieldsMixin, models.Model):
                 gateway, self, command='update_config'
             ).publish()
 
+    @transaction.atomic
     def rebuild_occupied_pins(self):
-        self.occupied_pins = {}
+        for pin in ColonelPin.objects.filter(colonel=self):
+            if isinstance(pin.occupied_by, Component):
+                pin.occupied_by_content_type = None
+                pin.occupied_by_id = None
+                pin.save()
+
         for component in self.components.all():
             try:
                 pins = component.controller._get_occupied_pins()
             except:
                 pins = []
-            for pin in pins:
-                self.occupied_pins[pin] = component.id
+            for no in pins:
+                pin, new = ColonelPin.objects.get_or_create(colonel=self, no=no)
+                pin.occupied_by = component
+                pin.save()
 
-        for i2c_interface in self.i2c_interfaces.all():
-            self.occupied_pins[i2c_interface.scl_pin] = 'scl_%d' % i2c_interface.no
-            self.occupied_pins[i2c_interface.sda_pin] = 'sda_%d' % i2c_interface.no
 
+    @transaction.atomic()
     def move_to(self, other_colonel):
+        # TODO: Need to replace pins on components!
         other_colonel.refresh_from_db()
         assert list(other_colonel.components.all()) == [], \
                "Other colonel must be completely empty!"
@@ -184,21 +188,102 @@ class Colonel(DirtyFieldsMixin, models.Model):
             component.config['colonel'] = other_colonel.id
             component.save()
             self.components.remove(component)
-            other_colonel.add(component)
-
-        other_colonel.i2c_interfaces.all().delete()
-        self.i2c_interfaces.all().update(colonel=other_colonel)
+            other_colonel.components.add(component)
 
         self.rebuild_occupied_pins()
-        self.save()
-
         other_colonel.rebuild_occupied_pins()
-        other_colonel.save()
+
+        other_colonel.i2c_interfaces.all().delete()
+
+        for i2c_interface in self.i2c_interfaces.all():
+            I2CInterface.objects.create(
+                colonel=other_colonel, name=i2c_interface.name,
+                freq=i2c_interface.freq,
+                scl_pin=ColonelPin.objects.get(
+                    colonel=other_colonel, no=i2c_interface.scl_pin.no,
+                ),
+                sda_pin=ColonelPin.objects.get(
+                    colonel=other_colonel, no=i2c_interface.sda_pin.no,
+                ),
+            )
 
         self.update_config()
         other_colonel.update_config()
 
 
+class ColonelPin(models.Model):
+    colonel = models.ForeignKey(
+        Colonel, related_name='pins', on_delete=models.CASCADE
+    )
+    no = models.PositiveIntegerField()
+    label = models.CharField(db_index=True, max_length=200)
+    input = models.BooleanField(default=False, db_index=True)
+    output = models.BooleanField(default=False, db_index=True)
+    capacitive = models.BooleanField(default=False, db_index=True)
+    adc = models.BooleanField(default=False)
+    native = models.BooleanField(default=True, db_index=True)
+    default_pull = models.CharField(
+        max_length=50, db_index=True, null=True, blank=True,
+        choices=(('LOW', "LOW"), ("HIGH", "HIGH"))
+    )
+    note = models.CharField(max_length=100)
+    occupied_by_content_type = models.ForeignKey(
+        ContentType, on_delete=models.CASCADE, null=True
+    )
+    occupied_by_id = models.PositiveIntegerField(null=True)
+    occupied_by = GenericForeignKey(
+        "occupied_by_content_type", "occupied_by_id"
+    )
+
+    objects = ColonelPinsManager()
+
+    class Meta:
+        unique_together = 'colonel', 'no'
+        indexes = [
+            models.Index(
+                fields=["occupied_by_content_type", "occupied_by_id"]
+            ),
+        ]
+    def __str__(self):
+        if not self.label:
+            # Might be created via migration...
+            self.save()
+        return self.label
+
+    def save(self, *args, **kwargs):
+        if self.native:
+            self.label = f'GPIO{self.no}'
+        else:
+            no = self.no - 100
+            self.label = f'IO{no}'
+        if self.note:
+            self.label += ' | %s' % self.note
+        return super().save(*args, **kwargs)
+
+
+@receiver(post_save, sender=Colonel)
+def after_colonel_save(sender, instance, created, *args, **kwargs):
+    if not created:
+        return
+
+    def after_update():
+        for no, data in GPIO_PINS.get(instance.type).items():
+            ColonelPin.objects.get_or_create(
+                colonel=instance, no=no,
+                input=data.get('input'), output=data.get('output'),
+                capacitive=data.get('capacitive'), adc=data.get('adc'),
+                native=data.get('native'), note=data.get('note')
+            )
+        if instance.type in ('ample-wall', 'game-changer'):
+            I2CInterface.objects.create(
+                colonel=instance, name='Main', no=0,
+                scl_pin=ColonelPin.objects.get(colonel=instance, no=4),
+                sda_pin=ColonelPin.objects.get(colonel=instance, no=15),
+            )
+        instance.update_config()
+
+    transaction.on_commit(after_update)
+
 
 @receiver(pre_delete, sender=Component)
 def post_component_delete(sender, instance, *args, **kwargs):
@@ -211,8 +296,7 @@ def post_component_delete(sender, instance, *args, **kwargs):
         for colonel in affected_colonels:
             print("Rebuild occupied pins for :", colonel)
             colonel.rebuild_occupied_pins()
-            colonel.save()
-            colonel.restart()
+            colonel.update_config()
 
     transaction.on_commit(update_colonel)
 
@@ -231,12 +315,24 @@ class I2CInterface(models.Model):
     no = models.IntegerField(
         default=0, choices=i2c_interface_no_choices
     )
-    scl_pin = models.IntegerField(default=4, choices=get_gpio_pins_choices())
-    sda_pin = models.IntegerField(default=15, choices=get_gpio_pins_choices())
+    scl_pin = models.ForeignKey(
+        ColonelPin, on_delete=models.CASCADE, limit_choices_to={
+            'native': True, 'output': True,
+        },
+        null=True, related_name='i2c_scl'
+    )
+    sda_pin = models.ForeignKey(
+        ColonelPin, on_delete=models.CASCADE, limit_choices_to={
+            'native': True, 'output': True,
+        },
+        null=True, related_name='i2c_sda'
+    )
     freq = models.IntegerField(
         default=100000, help_text="100000 - is a good middle point!"
     )
 
+    objects = I2CInterfacesManager()
+
     class Meta:
         unique_together = 'colonel', 'no'
 
@@ -244,56 +340,18 @@ class I2CInterface(models.Model):
         return self.name
 
 
-@receiver(post_delete, sender=I2CInterface)
-def post_i2c_interface_delete(sender, instance, *args, **kwargs):
-
-    def update_colonel():
-        try:
-            instance.colonel.rebuild_occupied_pins()
-            instance.colonel.save()
-        except Colonel.DoesNotExist: # deleting colonel
-            pass
-    transaction.on_commit(update_colonel)
-
-
 @receiver(post_save, sender=I2CInterface)
 def post_i2c_interface_delete(sender, instance, *args, **kwargs):
-
-    def update_colonel():
-        instance.colonel.rebuild_occupied_pins()
-        instance.colonel.save()
-    transaction.on_commit(update_colonel)
-
-
-# class BLEDevice(models.Model):
-#     mac = models.CharField(max_length=50, unique=True)
-#     name = models.CharField(max_length=50)
-#     addr = models.BinaryField(max_length=50)
-#     type = models.PositiveIntegerField(default=0, choices=(
-#         (0, "Unknown"),
-#         (BLE_DEVICE_TYPE_GOVEE_MULTISENSOR, "GOVEE Climate sensor")
-#     ))
-#     last_seen = models.DateTimeField(auto_now_add=True)
-#     component = models.ForeignKey(
-#         Component, null=True, blank=True, on_delete=models.SET_NULL,
-#         help_text='Only for tracking if it is already used as a component'
-#     )
-#     colonels = models.ManyToManyField(
-#         Colonel, through='ColonelBLEDevice', related_name='ble_devices'
-#     )
-#
-#     def __str__(self):
-#         return '%s (%s)' % (self.name, self.mac)
-#
-#
-# class ColonelBLEDevice(models.Model):
-#     colonel = models.ForeignKey(Colonel, on_delete=models.CASCADE)
-#     device = models.ForeignKey(BLEDevice, on_delete=models.CASCADE)
-#     last_seen = models.DateTimeField(auto_now_add=True)
-#     data = JSONField(default={})
-#
-#     def save(self, *args, **kwargs):
-#         obj = super().save(*args, **kwargs)
-#         self.device.last_seen = self.last_seen
-#         self.device.save()
-#         return obj
+    with transaction.atomic():
+        ct = ContentType.objects.get_for_model(instance)
+        for pin in ColonelPin.objects.filter(
+            occupied_by_content_type=ct,
+            occupied_by_id=instance.id
+        ):
+            pin.occupied_by_content_type = None
+            pin.occupied_by_content_id = None
+            pin.save()
+        instance.scl_pin.occupied_by = instance
+        instance.scl_pin.save()
+        instance.sda_pin.occupied_by = instance
+        instance.sda_pin.save()

simo/fleet/serializers.py

@@ -1,5 +1,5 @@
 from rest_framework import serializers
-from .models import InstanceOptions
+from .models import InstanceOptions, Colonel, ColonelPin
 
 
 class InstanceOptionsSerializer(serializers.ModelSerializer):
@@ -11,3 +11,37 @@ class InstanceOptionsSerializer(serializers.ModelSerializer):
 
     def get_instance(self, obj):
         return obj.instance.uid
+
+
+class ColonelPinSerializer(serializers.ModelSerializer):
+    occupied = serializers.SerializerMethodField()
+
+    class Meta:
+        model = ColonelPin
+        fields = 'id', 'label', 'occupied'
+        read_only_fields = fields
+
+    def get_occupied(self, obj):
+        return bool(obj.occupied_by)
+
+
+class ColonelSerializer(serializers.ModelSerializer):
+    pins = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Colonel
+        fields = (
+            'id', 'uid', 'name', 'type', 'firmware_version', 'firmware_auto_update',
+            'socket_connected', 'last_seen', 'enabled', 'pwm_frequency',
+            'logs_stream', 'pins'
+        )
+        read_only_fields = [
+            'uid', 'type', 'firmware_version', 'socket_connected',
+            'last_seen', 'pins'
+        ]
+
+    def get_pins(self, obj):
+        result = []
+        for pin in obj.pins.all():
+            result.append(ColonelPinSerializer(pin).data)
+        return result