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

simo/core/serializers.py

@@ -1,9 +1,20 @@
 import inspect
+import datetime
+import json
+from django import forms
+from django.forms.utils import ErrorDict
+from collections.abc import Iterable
 from easy_thumbnails.files import get_thumbnailer
 from simo.core.middleware import get_current_request
 from rest_framework import serializers
-from .models import Category, Zone, Component, Icon, ComponentHistory
-from .utils.type_constants import APP_WIDGETS
+from simo.core.forms import FormsetField
+from rest_framework.relations import PrimaryKeyRelatedField, ManyRelatedField
+from .drf_braces.serializers.form_serializer import (
+    FormSerializer, FormSerializerBase, reduce_attr_dict_from_instance,
+    FORM_SERIALIZER_FIELD_MAPPING, set_form_partial_validation
+)
+from .forms import ComponentAdminForm
+from .models import Category, Zone, Icon, ComponentHistory
 
 
 class TimestampField(serializers.Field):
@@ -13,6 +24,9 @@ class TimestampField(serializers.Field):
             return value.timestamp()
         return value
 
+    def to_internal_value(self, data):
+        return datetime.datetime.fromtimestamp(data)
+
 
 class IconSerializer(serializers.ModelSerializer):
     last_modified = TimestampField()
@@ -23,13 +37,15 @@ class IconSerializer(serializers.ModelSerializer):
 
 
 class CategorySerializer(serializers.ModelSerializer):
-    header_image = serializers.SerializerMethodField()
+    header_image_thumb = serializers.SerializerMethodField()
 
     class Meta:
         model = Category
-        fields = 'id', 'name', 'all', 'icon', 'header_image'
+        fields = (
+            'id', 'name', 'all', 'icon', 'header_image', 'header_image_thumb'
+        )
 
-    def get_header_image(self, obj):
+    def get_header_image_thumb(self, obj):
         if obj.header_image:
             url = get_thumbnailer(obj.header_image).get_thumbnail(
                 {'size': (830, 430), 'crop': True}
@@ -44,25 +60,318 @@ class CategorySerializer(serializers.ModelSerializer):
         return
 
 
-class ComponentSerializer(serializers.ModelSerializer):
+
+class ObjectSerializerMethodField(serializers.SerializerMethodField):
+
+    def bind(self, field_name, parent):
+        self.field_name = field_name
+        super().bind(field_name, parent)
+
+    def to_representation(self, value):
+        return getattr(value, self.field_name)
+
+
+class FormsetPrimaryKeyRelatedField(PrimaryKeyRelatedField):
+
+    def get_attribute(self, instance):
+        return self.queryset.model.objects.filter(
+            pk=instance.get(self.source_attrs[0], -1)
+        ).first()
+
+
+
+
+# TODO: if form field has initial value and is required, it is serialized as not required field, howerver when trying to submit it fails with a message, that field is required.
+
+
+class ComponentFormsetField(FormSerializer):
+
+    class Meta:
+        # fake form, but it is necessary for FormSerializer
+        # we set it to proper formset form on __init__
+        form = forms.Form
+        field_mapping = {
+            forms.ModelChoiceField: FormsetPrimaryKeyRelatedField,
+            forms.TypedChoiceField: serializers.ChoiceField,
+            forms.FloatField: serializers.FloatField,
+            forms.SlugField: serializers.CharField
+        }
+
+    def __init__(self, formset_field, *args, **kwargs):
+        self.Meta.form = formset_field.formset_cls.form
+        super().__init__(*args, **kwargs)
+
+    def get_fields(self):
+        ret = super(FormSerializerBase, self).get_fields()
+
+        field_mapping = reduce_attr_dict_from_instance(
+            self,
+            lambda i: getattr(getattr(i, 'Meta', None), 'field_mapping', {}),
+            FORM_SERIALIZER_FIELD_MAPPING
+        )
+
+        form = self.Meta.form
+        for field_name, form_field in getattr(form, 'all_base_fields', form.base_fields).items():
+
+            if field_name in getattr(self.Meta, 'exclude', []):
+                continue
+
+            if field_name in ret:
+                continue
+
+            cls_type = form_field.__class__
+            try:
+                serializer_field_class = field_mapping[cls_type]
+            except KeyError:
+                try:
+                    serializer_field_class = field_mapping[cls_type.__bases__[0]]
+                except KeyError:
+                    raise TypeError(
+                        "{field} is not mapped to a serializer field. "
+                        "Please add {field} to {serializer}.Meta.field_mapping. "
+                        "Currently mapped fields: {mapped}".format(
+                            field=form_field.__class__.__name__,
+                            serializer=self.__class__.__name__,
+                            mapped=', '.join(sorted([i.__name__ for i in field_mapping.keys()]))
+                        )
+                    )
+
+            ret[field_name] = self._get_field(form_field, serializer_field_class)
+
+        return ret
+
+    def _get_field_kwargs(self, form_field, serializer_field_class):
+        kwargs = super()._get_field_kwargs(form_field, serializer_field_class)
+        kwargs['style'] = {'form_field': form_field}
+        if serializer_field_class == FormsetPrimaryKeyRelatedField:
+            kwargs['queryset'] = form_field.queryset
+        return kwargs
+
+    def to_representation(self, instance):
+        return super(FormSerializerBase, self).to_representation(instance)
+
+    def get_form(self, data=None, **kwargs):
+        form = super().get_form(data=data, **kwargs)
+        form.prefix = ''
+        return form
+
+    def create(self, validated_data):
+        return validated_data
+
+
+class ComponentPrimaryKeyRelatedField(PrimaryKeyRelatedField):
+
+    def get_attribute(self, instance):
+        if self.queryset.model in (Icon, Zone, Category):
+            return super().get_attribute(instance)
+        return self.queryset.model.objects.filter(
+            pk=instance.config.get(self.source_attrs[0])
+        ).first()
+
+
+class ComponentManyToManyRelatedField(serializers.Field):
+
+    def __init__(self, *args, **kwargs):
+        self.queryset = kwargs.pop('queryset')
+        self.choices = {obj.pk: str(obj) for obj in self.queryset}
+        self.allow_blank = kwargs.pop('allow_blank', False)
+        super().__init__(*args, **kwargs)
+
+    def to_representation(self, value):
+        return [obj.pk for obj in value]
+
+    def to_internal_value(self, data):
+        if data == [] and self.allow_blank:
+            return []
+        return self.queryset.filter(pk__in=data)
+
+
+class ComponentSerializer(FormSerializer):
+    id = ObjectSerializerMethodField()
     controller_methods = serializers.SerializerMethodField()
-    last_change = TimestampField()
+    last_change = TimestampField(read_only=True)
     read_only = serializers.SerializerMethodField()
     app_widget = serializers.SerializerMethodField()
-    subcomponents = serializers.SerializerMethodField()
+    slaves = serializers.SerializerMethodField()
+    base_type = ObjectSerializerMethodField()
+    controller_uid = ObjectSerializerMethodField()
+    alive = ObjectSerializerMethodField()
+    value = ObjectSerializerMethodField()
+    config = ObjectSerializerMethodField()
+    meta = ObjectSerializerMethodField()
+    arm_status = ObjectSerializerMethodField()
+    battery_level = ObjectSerializerMethodField()
 
     class Meta:
-        model = Component
-        fields = [
-            'id', 'name', 'icon', 'zone',
-            'base_type', 'app_widget',
-            'category', 'alive',
-            'value', 'value_units',
-            'config', 'meta', 'controller_methods',
-            'alarm_category', 'arm_status', 'last_change',
-            'read_only', 'show_in_app', 'battery_level',
-            'subcomponents'
-        ]
+        form = ComponentAdminForm
+        exclude = ('instance_methods', )
+        field_mapping = {
+            forms.TypedChoiceField: serializers.ChoiceField,
+            forms.FloatField: serializers.FloatField,
+            forms.SlugField: serializers.CharField,
+            forms.ModelChoiceField: ComponentPrimaryKeyRelatedField,
+            forms.ModelMultipleChoiceField: ComponentManyToManyRelatedField,
+            FormsetField: ComponentFormsetField,
+        }
+
+    def get_fields(self):
+        self.set_form_cls()
+
+        ret = super(FormSerializerBase, self).get_fields()
+
+        field_mapping = reduce_attr_dict_from_instance(
+            self,
+            lambda i: getattr(getattr(i, 'Meta', None), 'field_mapping', {}),
+            FORM_SERIALIZER_FIELD_MAPPING
+        )
+
+        if not self.instance or isinstance(self.instance, Iterable):
+            form = self.Meta.form()
+        else:
+            form = self.Meta.form(instance=self.instance)
+        for field_name in form.fields:
+            # if field is specified as excluded field
+            if field_name in getattr(self.Meta, 'exclude', []):
+                continue
+
+            # if field is already defined via declared fields
+            # skip mapping it from forms which then honors
+            # the custom validation defined on the DRF declared field
+            if field_name in ret:
+                continue
+
+            form_field = form[field_name]
+
+            cls = form_field.field.__class__
+            try:
+                serializer_field_class = field_mapping[cls]
+            except KeyError:
+                cls = form_field.field.__class__.__bases__[0]
+                try:
+                    serializer_field_class = field_mapping[cls]
+                except KeyError:
+                    raise TypeError(
+                        "{field} is not mapped to a serializer field. "
+                        "Please add {field} to {serializer}.Meta.field_mapping. "
+                        "Currently mapped fields: {mapped}".format(
+                            field=form_field.field.__class__.__name__,
+                            serializer=self.__class__.__name__,
+                            mapped=', '.join(sorted([i.__name__ for i in field_mapping.keys()]))
+                        )
+                    )
+
+            ret[field_name] = self._get_field(
+                form_field.field, serializer_field_class
+            )
+            ret[field_name].initial = form_field.initial
+            ret[field_name].default = form_field.initial
+
+        return ret
+
+    def _get_field_kwargs(self, form_field, serializer_field_class):
+        kwargs = super()._get_field_kwargs(form_field, serializer_field_class)
+        kwargs['style'] = {'form_field': form_field}
+        if serializer_field_class == ComponentPrimaryKeyRelatedField:
+            kwargs['queryset'] = form_field.queryset
+        elif serializer_field_class == ComponentManyToManyRelatedField:
+            kwargs['queryset'] = form_field.queryset
+        elif serializer_field_class == ComponentFormsetField:
+            kwargs['formset_field'] = form_field
+            kwargs['many'] = True
+
+        return kwargs
+
+    def set_form_cls(self):
+        self.Meta.form = ComponentAdminForm
+        if not isinstance(self.instance, Iterable):
+            from .utils.type_constants import get_controller_types_map
+            controllers_map = get_controller_types_map()
+            if not self.instance:
+                controller = controllers_map.get(
+                    #'simo.generic.controllers.AlarmClock'
+                    self.context['request'].META.get('HTTP_CONTROLLER')
+                )
+                if controller:
+                    self.Meta.form = controller.add_form
+            else:
+                controller = controllers_map.get(
+                    self.instance.controller_uid
+                )
+                if controller:
+                    self.Meta.form = controller.config_form
+
+    def get_form(self, data=None, **kwargs):
+        self.set_form_cls()
+        if not self.instance:
+            #controller_uid = 'simo.generic.controllers.AlarmClock'
+            controller_uid = self.context['request'].META.get('HTTP_CONTROLLER')
+        else:
+            controller_uid = self.instance.controller_uid
+        form = self.Meta.form(
+            data=data, request=self.context['request'],
+            controller_uid=controller_uid,
+            **kwargs
+        )
+        return form
+
+    def accomodate_formsets(self, form, data):
+        new_data = {}
+        field_types = {}
+        for field_name in form.fields:
+            field_types[field_name] = form[field_name]
+        for key, val in data.items():
+            if isinstance(field_types.get(key).field, FormsetField):
+                new_data[f'{key}-TOTAL_FORMS'] = len(val)
+                new_data[f'{key}-INITIAL_FORMS'] = len(val)
+                new_data[f'{key}-MIN_NUM_FORMS'] = 0
+                new_data[f'{key}-MAX_NUM_FORMS'] = len(val)
+                for i, item in enumerate(val):
+                    for k, v in item.items():
+                        new_data[f'{key}-{i}-{k}'] = v
+            else:
+                new_data[key] = val
+        return new_data
+
+    def validate(self, data):
+        if not self.instance:
+            try:
+                self.context['request'].META['HTTP_CONTROLLER']
+            except:
+                raise serializers.ValidationError(
+                    ["Controller header is not supplied!"]
+                )
+        form = self.get_form(instance=self.instance)
+        a_data = self.accomodate_formsets(form, data)
+        form = self.get_form(
+            data=a_data, instance=self.instance
+        )
+        if not form.is_valid():
+            raise serializers.ValidationError(form.errors)
+        return data
+
+    def to_representation(self, instance):
+        return super(FormSerializerBase, self).to_representation(instance)
+
+    def update(self, instance, validated_data):
+        form = self.get_form(instance=instance)
+        a_data = self.accomodate_formsets(form, validated_data)
+        form = self.get_form(instance=instance, data=a_data)
+        if form.is_valid():
+            instance = form.save(commit=True)
+            return instance
+        raise serializers.ValidationError(form.errors)
+
+    def create(self, validated_data):
+        form = self.get_form()
+        a_data = self.accomodate_formsets(form, validated_data)
+        form = self.get_form(data=a_data)
+        if form.is_valid():
+            if form.controller.is_discoverable:
+                form.controller.init_discovery(form.cleaned_data)
+                return {'discovery': 'started'}
+            instance = form.save(commit=True)
+            return instance
+        raise serializers.ValidationError(form.errors)
 
     def get_controller_methods(self, obj):
         c_methods = [m[0] for m in inspect.getmembers(
@@ -92,13 +401,8 @@ class ComponentSerializer(serializers.ModelSerializer):
             return {}
         return {'type': app_widget.uid, 'size': app_widget.size}
 
-    def get_subcomponents(self, obj):
-        from simo.users.utils import get_system_user
-        return ComponentSerializer(
-            obj.subcomponents.all(), many=True, context={
-                'user': get_system_user()
-            }
-        ).data
+    def get_slaves(self, obj):
+        return [c['id'] for c in obj.slaves.all().values('id')]
 
 
 class ZoneSerializer(serializers.ModelSerializer):

simo/core/socket_consumers.py

@@ -1,29 +1,17 @@
 import json
-import time
-import pytz
 import asyncio
-import os
-import logging
 from ansi2html import Ansi2HTMLConverter
 from asgiref.sync import sync_to_async
-from django.urls import set_script_prefix
-from django.core.exceptions import ValidationError
 from django.template.loader import render_to_string
 from django.conf import settings
-from django.utils import timezone
 from django.contrib.contenttypes.models import ContentType
 from channels.generic.websocket import AsyncWebsocketConsumer, WebsocketConsumer
 from simo.core.events import ObjectChangeEvent, get_event_obj
 import paho.mqtt.client as mqtt
 from simo.users.middleware import introduce
-from simo.core.api import get_components_queryset
 from simo.core.models import Component, Gateway
-from simo.core.serializers import ComponentSerializer
-from simo.conf import dynamic_settings
-from simo.users.models import User, PermissionsRole
-from simo.users.serializers import UserSerializer
-from simo.users.api import UsersViewSet
 from simo.core.utils.model_helpers import get_log_file_path
+from simo.core.middleware import introduce_instance
 
 
 class SIMOWebsocketConsumer(WebsocketConsumer):
@@ -220,6 +208,8 @@ class ComponentController(SIMOWebsocketConsumer):
         if not self.scope['user'].is_active:
             return self.close()
 
+        introduce_instance(self.component.zone.instance)
+
         self._mqtt_client = mqtt.Client()
         self._mqtt_client.username_pw_set('root', settings.SECRET_KEY)
         self._mqtt_client.on_connect = self._on_mqtt_connect
@@ -228,7 +218,6 @@ class ComponentController(SIMOWebsocketConsumer):
                                  port=settings.MQTT_PORT)
         self._mqtt_client.loop_start()
 
-
     def _on_mqtt_connect(self, mqtt_client, userdata, flags, rc):
         print("Subscribing to ComponentEvent's")
         event = ObjectChangeEvent(self.component.zone.instance, self.component)
@@ -238,6 +227,7 @@ class ComponentController(SIMOWebsocketConsumer):
         payload = json.loads(msg.payload)
         component = get_event_obj(payload, Component)
         if component == self.component:
+            introduce_instance(self.component.zone.instance)
             # print("Object changed [%s], %s" % (str(component), payload))
             self.component = component
             if self.send_value:
@@ -254,6 +244,7 @@ class ComponentController(SIMOWebsocketConsumer):
 
     def receive(self, text_data=None, bytes_data=None, **kwargs):
         introduce(self.scope['user'])
+        introduce_instance(self.component.zone.instance)
         json_data = json.loads(text_data)
         self.send_value = json_data.pop('send_value', False)
         for method, param in json_data.items():

simo/core/tasks.py

@@ -192,7 +192,7 @@ def sync_with_remote():
             ).first()
             if weather_component:
                 weather_component.track_history = False
-                weather_component.set(data['weather_forecast'])
+                weather_component.controller.set(data['weather_forecast'])
 
         instance.save()
 
@@ -313,6 +313,16 @@ def drop_fingerprints_learn():
     )
 
 
+@celery_app.task
+def time_out_discoveries():
+    from .models import Gateway
+    for gw in Gateway.objects.filter(
+        discovery__has_key='start'
+    ).exclude(discovery__has_key='finished'):
+        if time.time() - gw.discovery['start'] > gw.discovery['timeout']:
+            gw.finish_discovery()
+
+
 @celery_app.on_after_finalize.connect
 def setup_periodic_tasks(sender, **kwargs):
     sender.add_periodic_task(1, watch_timers.s())

simo/core/templates/admin/base.html

@@ -81,28 +81,50 @@
 <body class="{% if is_popup %}popup {% endif %}{% block bodyclass %}{% endblock %}"
   data-admin-utc-offset="{% now "Z" %}">
 
+
+<style>
+  #instance-select{
+    background: none;
+    color: #f3ff4a;
+    font-family: 'Russo One';
+    font-size: 1rem;
+    border: none;
+  }
+  #instance-select option{
+    background-color: #08172a;
+  }
+</style>
 <!-- Container -->
 <div id="container">
 
     {% if not is_popup %}
     <!-- Header -->
-    <div id="header">
-      <a href="/admin/">
-        <div id="branding" style="background-image: url({% static 'logo/logo_color_bg_b.svg' %})"></div>
-
+    <div id="header" style="display:flex">
+      <div style="display:flex">
+        <a href="/admin/" >
+          <div id="branding" style="background-image: url({% static 'logo/logo_color_bg_b.svg' %})"></div>
+        </a>
         <div style="
               color: white;
               font-size: 16px;
-              padding: 11px 0px;
+              padding: 7px 0px;
               margin-top: 4px;
-              display: inline-block;
           ">
           <span style="display: inline-block; margin-right: 6px">|</span>
-          <span style="display: inline-block; font-family: 'Russo One'; color: #f3ff4a;">
-            {% if instances|length == 1 %}{{ instances.0.name }}{% else %}Hub Admin{% endif %}
-          </span>
+          <select id="instance-select">
+            {% for instance in instances %}
+              <option
+                data-set_url="{% url 'set-instance' instance_slug=instance.slug %}"
+                {% if instance == current_instance %} selected {% endif %}
+              >{{ instance }}</option>
+            {% endfor %}
+          </select>
+<!--          <span style="display: inline-block; font-family: 'Russo One'; color: #f3ff4a;">-->
+<!--            {% if instances|length == 1 %}{{ instances.0.name }}{% else %}Hub Admin{% endif %}-->
+<!--          </span>-->
         </div>
-      </a>
+      </div>
+      
         {% block usertools %}
           {% include 'admin/user_tools.html' %}
         {% endblock %}
@@ -146,5 +168,10 @@
 <script src="{% static 'third_party/precision-inputs/precision-inputs.fl-controls.js' %}"></script>
 <script src="{% static 'admin/js/admin_scripts.js' %}"></script>
 
+<script>
+  $('#instance-select').on('change', function(){
+    window.location = $(this).find('option:selected').data('set_url');
+  })
+</script>
 </body>
 </html>