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

simo/fleet/forms.py

@@ -5,12 +5,22 @@ from django.urls.base import get_script_prefix
 from django.contrib.contenttypes.models import ContentType
 from dal import autocomplete
 from dal import forward
+from simo.core.models import Component
 from simo.core.forms import BaseComponentForm, ValueLimitForm, NumericSensorForm
 from simo.core.utils.formsets import FormsetField
 from simo.core.widgets import LogOutputWidget
 from simo.core.utils.easing import EASING_CHOICES
-from .models import Colonel, I2CInterface, i2c_interface_no_choices
-from .utils import get_gpio_pins_choices, get_available_gpio_pins
+from simo.core.utils.validators import validate_slaves
+from simo.core.utils.admin import AdminFormActionForm
+from .models import Colonel, ColonelPin, I2CInterface, i2c_interface_no_choices
+
+
+class ColonelPinChoiceField(forms.ModelChoiceField):
+    '''
+    Required for API, so that SIMO app could properly handle
+    fleet components configuration.
+    '''
+    filter_by = 'colonel'
 
 
 class ColonelAdminForm(forms.ModelForm):
@@ -36,32 +46,32 @@ class ColonelAdminForm(forms.ModelForm):
             )
 
 
-class MoveColonelForm(forms.Form):
+class MoveColonelForm(AdminFormActionForm):
     colonel = forms.ModelChoiceField(
         label="Move to:", queryset=Colonel.objects.filter(components=None),
     )
 
 
 class I2CInterfaceAdminForm(forms.ModelForm):
-    scl_pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    scl_pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(output=True, native=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
                 forward.Self(),
                 forward.Field('colonel'),
-                forward.Const({'output': True}, 'filters')
+                forward.Const({'output': True, 'native': True}, 'filters')
             ]
         )
     )
-    sda_pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    sda_pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(output=True, native=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
                 forward.Self(),
                 forward.Field('colonel'),
-                forward.Const({'output': True}, 'filters')
+                forward.Const({'output': True, 'native': True}, 'filters')
             ]
         )
     )
@@ -71,31 +81,21 @@ class I2CInterfaceAdminForm(forms.ModelForm):
         fields = '__all__'
 
     def clean_scl_pin(self):
-        initial = None
-        if self.instance.pk:
-            initial = self.instance.scl_pin
-        available_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'], filters={'output': True},
-            selected=initial
-        )
-        if self.cleaned_data['scl_pin'] not in available_pins:
-            raise forms.ValidationError("Pin is unavailable.")
+        if self.cleaned_data['scl_pin'].occupied_by \
+        and self.cleaned_data['scl_pin'].occupied_by  != self.instance:
+            raise forms.ValidationError(
+                f"This pin is already occupied by "
+                f"{self.cleaned_data['scl_pin'].occupied_by}!"
+            )
         return self.cleaned_data['scl_pin']
 
     def clean_sda_pin(self):
-        initial = None
-        if self.instance.pk:
-            initial = self.instance.sda_pin
-        available_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'], filters={'output': True},
-            selected=initial
-        )
-        if self.cleaned_data['sda_pin'] not in available_pins:
-            raise forms.ValidationError("Pin is unavailable.")
-
-        if self.cleaned_data.get('scl_pin') == self.cleaned_data['sda_pin']:
-            raise forms.ValidationError("Can not be the same as SCL pin!")
-
+        if self.cleaned_data['sda_pin'].occupied_by \
+                and self.cleaned_data['sda_pin'].occupied_by != self.instance:
+            raise forms.ValidationError(
+                f"This pin is already occupied by "
+                f"{self.cleaned_data['sda_pin'].occupied_by}!"
+            )
         return self.cleaned_data['sda_pin']
 
 
@@ -105,14 +105,66 @@ class ColonelComponentForm(BaseComponentForm):
         help_text="ATENTION! Changing Colonel after component creation is not recommended!"
     )
 
-    # def clean_colonel(self):
-    #     org = self.instance.config.get('colonel')
-    #     if org and org != self.cleaned_data['colonel'].id:
-    #         raise forms.ValidationError(
-    #             "Changing colonel after component is created "
-    #             "it is not allowed."
-    #         )
-    #     return self.cleaned_data['colonel']
+    def clean_colonel(self):
+        org = self.instance.config.get('colonel')
+        if org and org != self.cleaned_data['colonel'].id:
+            raise forms.ValidationError(
+                "Changing colonel after component is created "
+                "it is not allowed!"
+            )
+        return self.cleaned_data['colonel']
+
+    def _clean_pin(self, field_name):
+        if self.cleaned_data[field_name].colonel != self.cleaned_data['colonel']:
+            self.add_error(
+                field_name, "Pin must be from the same Colonel!"
+            )
+            return
+        if self.cleaned_data[field_name].occupied_by \
+        and self.cleaned_data[field_name].occupied_by != self.instance:
+            self.add_error(
+                field_name,
+                f"Pin is already occupied by {self.cleaned_data[field_name].occupied_by}!"
+            )
+
+    def _clean_controls(self):
+        # TODO: Formset factory should return proper field value types instead of str type
+
+        pin_instances = {}
+        for i, control in enumerate(self.cleaned_data['controls']):
+            updated_vals = {}
+            for key, val in control.items():
+                updated_vals[key] = val
+                if key == 'pin':
+                    pin = ColonelPin.objects.get(
+                        id=self.cleaned_data['controls'][i]['pin']
+                    )
+                    pin_instances[i] = pin
+                    updated_vals['pin_no'] = pin.no
+                elif key == 'touch_threshold':
+                    updated_vals[key] = int(val)
+            self.cleaned_data['controls'][i] = updated_vals
+
+        formset_errors = {}
+        for i, control in enumerate(self.cleaned_data['controls']):
+            if pin_instances[i].colonel != self.cleaned_data['colonel']:
+                formset_errors[i] = {
+                    'pin': f"{pin_instances[i]} must be from the same Colonel!"
+                }
+            elif pin_instances[i].occupied_by \
+            and pin_instances[i].occupied_by != self.instance:
+                formset_errors[i] = {
+                    'pin': f"{pin_instances[i]} is already occupied by {pin_instances[i].occupied_by}!"
+                }
+
+        errors_list = []
+        if formset_errors:
+            for i, control in enumerate(self.cleaned_data['controls']):
+                errors_list.append(formset_errors.get(i, {}))
+        if errors_list:
+            self._errors['controls'] = errors_list
+            if 'controls' in self.cleaned_data:
+                del self.cleaned_data['controls']
 
     def save(self, commit=True):
         obj = super().save(commit)
@@ -125,9 +177,8 @@ class ColonelComponentForm(BaseComponentForm):
 
 
 class ControlPinForm(forms.Form):
-    pin = forms.TypedChoiceField(
-        coerce=int, required=True, choices=get_gpio_pins_choices,
-        help_text="Use this if you also want to wire up a wall switch",
+    pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(input=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
@@ -143,23 +194,14 @@ class ControlPinForm(forms.Form):
     method = forms.ChoiceField(
         required=True, choices=(
             ('momentary', "Momentary"), ('toggle', "Toggle"),
-            ('touch', "Touch")
         ),
     )
-    touch_threshold = forms.IntegerField(
-        min_value=0, max_value=999999999, required=False, initial=1000,
-        help_text="Used to detect touch events. "
-                  "Smaller value means a higher sensitivity. "
-                  "1000 offers good starting point. <br> "
-                  "Used only when controll method is set to Touch."
-
-    )
     prefix = 'controls'
 
 
 class ColonelBinarySensorConfigForm(ColonelComponentForm):
-    pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(input=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
@@ -193,27 +235,15 @@ class ColonelBinarySensorConfigForm(ColonelComponentForm):
 
     def clean(self):
         super().clean()
-        if 'colonel' not in self.cleaned_data:
+        if not self.cleaned_data.get('colonel'):
             return self.cleaned_data
         if 'pin' not in self.cleaned_data:
             return self.cleaned_data
-        if self.instance.pk:
-            selected = self.instance.config.get('pin')
-        else:
-            selected = None
-        input_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'], filters={'input': True},
-            selected=selected
-        )
-        if self.cleaned_data['pin'] not in input_pins:
-            self.add_error(
-                'pin',
-                "Sorry, but GPIO%d pin can not be used as input pin "
-                % self.cleaned_data['pin']
-            )
-            return
-        if self.cleaned_data['pin'] > 100:
-            if self.cleaned_data['pin'] < 126:
+
+        self._clean_pin('pin')
+
+        if self.cleaned_data['pin'].no > 100:
+            if self.cleaned_data['pin'].no < 126:
                 if self.cleaned_data.get('pull') == 'HIGH':
                     self.add_error(
                         'pull',
@@ -233,30 +263,33 @@ class ColonelBinarySensorConfigForm(ColonelComponentForm):
                     )
 
         elif self.cleaned_data.get('pull') != 'FLOATING':
-            pins_available_for_pull = get_available_gpio_pins(
-                self.cleaned_data['colonel'], filters={'output': True},
-                selected=selected
-            )
-            if self.cleaned_data['pin'] not in pins_available_for_pull:
+            if not self.cleaned_data['pin'].output:
                 self.add_error(
                     'pin',
-                    "Sorry, but GPIO%d pin does not have internal pull HIGH/LOW"
-                    " resistance capability" % self.cleaned_data['pin']
+                    f"Sorry, but {self.cleaned_data['pin']} "
+                    f"does not have internal pull HIGH/LOW"
+                    " resistance capability"
                 )
-                return
 
         return self.cleaned_data
 
 
+    def save(self, commit=True):
+        self.instance.config['pin_no'] = self.cleaned_data['pin'].no
+        return super().save(commit=commit)
+
+
 class ColonelNumericSensorConfigForm(ColonelComponentForm, NumericSensorForm):
-    pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(adc=True, input=True, native=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
                 forward.Self(),
                 forward.Field('colonel'),
-                forward.Const({'adc': True}, 'filters')
+                forward.Const(
+                    {'adc': True, 'native': True, 'input': True}, 'filters'
+                )
             ]
         )
     )
@@ -282,37 +315,32 @@ class ColonelNumericSensorConfigForm(ColonelComponentForm, NumericSensorForm):
 
     def clean(self):
         super().clean()
-        if 'colonel' not in self.cleaned_data:
+        if not self.cleaned_data.get('colonel'):
             return self.cleaned_data
         if 'pin' not in self.cleaned_data:
             return self.cleaned_data
-        if self.instance.pk:
-            selected = self.instance.config.get('pin')
-        else:
-            selected = None
-        input_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'], filters={'adc': True},
-            selected=selected
-        )
-        if self.cleaned_data['pin'] not in input_pins:
-            self.add_error(
-                'pin',
-                "Sorry, but GPIO%d pin can not be used as ADC input pin "
-                % self.cleaned_data['pin']
-            )
-            return
+
+        self._clean_pin('pin')
+
         return self.cleaned_data
 
 
-class DS18B20SensorConfigForm(ColonelComponentForm):
-    pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    def save(self, commit=True):
+        self.instance.config['pin_no'] = self.cleaned_data['pin'].no
+        return super().save(commit=commit)
+
+
+class DS18B20SensorConfigForm(ColonelComponentForm, NumericSensorForm):
+    pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(input=True, native=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
                 forward.Self(),
                 forward.Field('colonel'),
-                forward.Const({'input': True, 'native': True}, 'filters')
+                forward.Const(
+                    {'native': True, 'input': True}, 'filters'
+                )
             ]
         )
     )
@@ -325,37 +353,32 @@ class DS18B20SensorConfigForm(ColonelComponentForm):
 
     def clean(self):
         super().clean()
-        if 'colonel' not in self.cleaned_data:
+        if not self.cleaned_data.get('colonel'):
             return self.cleaned_data
         if 'pin' not in self.cleaned_data:
             return self.cleaned_data
-        if self.instance.pk:
-            selected = self.instance.config.get('pin')
-        else:
-            selected = None
-        input_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'], filters={'adc': True},
-            selected=selected
-        )
-        if self.cleaned_data['pin'] not in input_pins:
-            self.add_error(
-                'pin',
-                "Sorry, but GPIO%d pin can not be used"
-                % self.cleaned_data['pin']
-            )
-            return
+
+        self._clean_pin('pin')
+
         return self.cleaned_data
 
+    def save(self, commit=True):
+        self.instance.config['pin_no'] = self.cleaned_data['pin'].no
+        return super().save(commit=commit)
+
+
 
 class ColonelDHTSensorConfigForm(ColonelComponentForm):
-    pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(input=True, native=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
                 forward.Self(),
                 forward.Field('colonel'),
-                forward.Const({'input': True, 'native': True}, 'filters')
+                forward.Const(
+                    {'native': True, 'input': True}, 'filters'
+                )
             ]
         )
     )
@@ -376,27 +399,19 @@ class ColonelDHTSensorConfigForm(ColonelComponentForm):
 
     def clean(self):
         super().clean()
-        if 'colonel' not in self.cleaned_data:
+        if not self.cleaned_data.get('colonel'):
             return self.cleaned_data
         if 'pin' not in self.cleaned_data:
             return self.cleaned_data
-        if self.instance.pk:
-            selected = self.instance.config.get('pin')
-        else:
-            selected = None
-        input_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'], filters={'adc': True},
-            selected=selected
-        )
-        if self.cleaned_data['pin'] not in input_pins:
-            self.add_error(
-                'pin',
-                "Sorry, but GPIO%d pin can not be used"
-                % self.cleaned_data['pin']
-            )
-            return
+
+        self._clean_pin('pin')
+
         return self.cleaned_data
 
+    def save(self, commit=True):
+        self.instance.config['pin_no'] = self.cleaned_data['pin'].no
+        return super().save(commit=commit)
+
 
 class BME680SensorConfigForm(ColonelComponentForm):
     i2c_interface = forms.TypedChoiceField(
@@ -410,7 +425,8 @@ class BME680SensorConfigForm(ColonelComponentForm):
         )
     )
     i2c_address = forms.IntegerField(
-        help_text="Integer: 0 - 127", min_value=0, max_value=127
+        min_value=0, max_value=127, initial=118,
+        help_text="Integer: 0 - 127. Dafault: 118"
     )
     read_frequency_s = forms.IntegerField(
         initial=60, min_value=1, max_value=60*60*24,
@@ -420,15 +436,38 @@ class BME680SensorConfigForm(ColonelComponentForm):
     )
 
 
+class MPC9808SensorConfigForm(ColonelComponentForm):
+    i2c_interface = forms.TypedChoiceField(
+        coerce=int, choices=i2c_interface_no_choices,
+        widget=autocomplete.ListSelect2(
+            url='autocomplete-colonel-i2c_interfaces',
+            forward=[
+                forward.Self(),
+                forward.Field('colonel'),
+            ]
+        )
+    )
+    i2c_address = forms.IntegerField(
+        min_value=0, max_value=127, initial=24,
+        help_text="Integer: 0 - 127. Default: 24",
+    )
+    read_frequency_s = forms.IntegerField(
+        initial=60, min_value=1, max_value=60 * 60 * 24,
+        help_text='read and report temperature value every s. '
+                  'Can not be less than 1s.'
+
+    )
+
+
 class ColonelTouchSensorConfigForm(ColonelComponentForm):
-    pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(input=True, capacitive=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
                 forward.Self(),
                 forward.Field('colonel'),
-                forward.Const({'capacitive': True}, 'filters')
+                forward.Const({'input': True, 'capacitive': True}, 'filters')
             ]
         )
     )
@@ -439,45 +478,28 @@ class ColonelTouchSensorConfigForm(ColonelComponentForm):
                   "1000 offers good starting point."
 
     )
-    inverse = forms.ChoiceField(choices=(('no', "No"), ('yes', "Yes")))
+    inverse = forms.ChoiceField(choices=((0, "No"), (1, "Yes")))
 
     def clean(self):
         super().clean()
-        if 'colonel' not in self.cleaned_data:
+        if not self.cleaned_data.get('colonel'):
             return self.cleaned_data
         if 'pin' not in self.cleaned_data:
             return self.cleaned_data
-        if self.instance.pk:
-            selected = self.instance.config.get('pin')
-        else:
-            selected = None
-        free_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'], selected=selected
-        )
-        if self.cleaned_data['pin'] not in free_pins:
-            self.add_error(
-                'pin',
-                "Sorry, but GPIO%d pin is occupied."
-                % self.cleaned_data['pin']
-            )
-            return
-        touch_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'], filters={'capacitive': True},
-            selected=selected
-        )
-        if self.cleaned_data['pin'] not in touch_pins:
-            self.add_error(
-                'pin',
-                "Sorry, but GPIO%d pin can not be used as input pin "
-                % self.cleaned_data['pin']
-            )
-            return
+
+        self._clean_pin('pin')
+
         return self.cleaned_data
 
 
+    def save(self, commit=True):
+        self.instance.config['pin_no'] = self.cleaned_data['pin'].no
+        return super().save(commit=commit)
+
+
 class ColonelSwitchConfigForm(ColonelComponentForm):
-    output_pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    output_pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(output=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
@@ -498,6 +520,20 @@ class ColonelSwitchConfigForm(ColonelComponentForm):
     inverse = forms.BooleanField(
         label=_("Inverse switch value"), required=False
     )
+    slaves = forms.ModelMultipleChoiceField(
+        required=False,
+        queryset=Component.objects.filter(
+            base_type__in=(
+                'dimmer', 'switch', 'blinds', 'script'
+            )
+        ),
+        widget=autocomplete.ModelSelect2Multiple(
+            url='autocomplete-component', attrs={'data-html': True},
+            forward=(forward.Const(
+                ['dimmer', 'switch', 'blinds', 'script'], 'base_type'),
+            )
+        )
+    )
 
     controls = FormsetField(
         formset_factory(
@@ -505,62 +541,37 @@ class ColonelSwitchConfigForm(ColonelComponentForm):
         )
     )
 
+    def clean_slaves(self):
+        if not self.cleaned_data['slaves'] or not self.instance:
+            return self.cleaned_data['slaves']
+        return validate_slaves(self.cleaned_data['slaves'], self.instance)
+
+
     def clean(self):
         super().clean()
-        if 'colonel' not in self.cleaned_data:
+        if not self.cleaned_data.get('colonel'):
             return self.cleaned_data
         if not self.cleaned_data.get('output_pin'):
             return self.cleaned_data
-        if self.instance.pk:
-            selected = self.instance.config.get('output_pin')
-        else:
-            selected = None
-        output_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'], filters={'output': True},
-            selected=selected
-        )
-        if self.cleaned_data['output_pin'] not in output_pins:
-            self.add_error(
-                'output_pin',
-                "Sorry, but GPIO%d pin can not be used as output pin "
-                % self.cleaned_data['output_pin']
-            )
-            return self.cleaned_data
 
-        if 'controls' not in self.cleaned_data:
-            return self.cleaned_data
+        self._clean_pin('output_pin')
 
-        # TODO: Formset factory should return proper field value types instead of str type
-        for i, control in enumerate(self.cleaned_data['controls']):
-            for key, val in control.items():
-                if key in ('pin', 'touch_threshold'):
-                    self.cleaned_data['controls'][i][key] = int(val)
-                else:
-                    self.cleaned_data['controls'][i][key] = val
+        if not self.cleaned_data.get('controls'):
+            return self.cleaned_data
 
-        for i, control in enumerate(self.cleaned_data['controls']):
-            try:
-                selected = self.instance.config['controls'][i]['pin']
-            except:
-                selected = None
-            free_pins = get_available_gpio_pins(
-                self.cleaned_data['colonel'], filters={'input': True},
-                selected=selected
-            )
-            if control['pin'] not in free_pins:
-                self.add_error(
-                    'controls',
-                    "Sorry, but GPIO%d pin is occupied."
-                    % control['pin']
-                )
-                return
+        self._clean_controls()
 
         return self.cleaned_data
 
 
+    def save(self, commit=True):
+        self.instance.config['output_pin_no'] = self.cleaned_data['output_pin'].no
+        return super().save(commit=commit)
+
+
 class ColonelPWMOutputConfigForm(ColonelComponentForm):
-    output_pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    output_pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(output=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
@@ -613,70 +624,52 @@ class ColonelPWMOutputConfigForm(ColonelComponentForm):
         required=True, initial=100,
         help_text="Component ON value when used with toggle switch"
     )
+    slaves = forms.ModelMultipleChoiceField(
+        required=False,
+        queryset=Component.objects.filter(
+            base_type__in=('dimmer', ),
+        ),
+        widget=autocomplete.ModelSelect2Multiple(
+            url='autocomplete-component', attrs={'data-html': True},
+            forward=(forward.Const(['dimmer', ], 'base_type'),)
+        )
+    )
     controls = FormsetField(
         formset_factory(
             ControlPinForm, can_delete=True, can_order=True, extra=0, max_num=1
         )
     )
 
+    def clean_slaves(self):
+        if not self.cleaned_data['slaves'] or not self.instance:
+            return self.cleaned_data['slaves']
+        return validate_slaves(self.cleaned_data['slaves'], self.instance)
+
     def clean(self):
         super().clean()
-        if 'colonel' not in self.cleaned_data:
+        if not self.cleaned_data.get('colonel'):
             return self.cleaned_data
         if not self.cleaned_data.get('output_pin'):
             return self.cleaned_data
-        if self.instance.pk:
-            selected = self.instance.config.get('output_pin')
-        else:
-            self.cleaned_data['value_units'] = '%'
-            selected = None
-        output_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'], filters={'output': True},
-            selected=selected
-        )
-        if self.cleaned_data['output_pin'] not in output_pins:
-            self.add_error(
-                'output_pin',
-                "Sorry, but GPIO%d pin can not be used as output pin "
-                % self.cleaned_data['output_pin']
-            )
-            return self.cleaned_data
 
-        if 'controls' not in self.cleaned_data:
+        self._clean_pin('output_pin')
+
+        if not self.cleaned_data.get('controls'):
             return self.cleaned_data
 
+        self._clean_controls()
 
-        # TODO: Formset factory should return proper field value types instead of str type
-        for i, control in enumerate(self.cleaned_data['controls']):
-            for key, val in control.items():
-                if key in ('pin', 'touch_threshold'):
-                    self.cleaned_data['controls'][i][key] = int(val)
-                else:
-                    self.cleaned_data['controls'][i][key] = val
+        return self.cleaned_data
 
-        for i, control in enumerate(self.cleaned_data['controls']):
-            try:
-                selected = self.instance.config['controls'][i]['pin']
-            except:
-                selected = None
-            free_pins = get_available_gpio_pins(
-                self.cleaned_data['colonel'], filters={'input': True},
-                selected=selected
-            )
-            if control['pin'] not in free_pins:
-                self.add_error(
-                    'controls',
-                    "Sorry, but GPIO%d pin is occupied."
-                    % control['pin']
-                )
-                return
 
-        return self.cleaned_data
+    def save(self, commit=True):
+        self.instance.config['output_pin_no'] = self.cleaned_data['output_pin'].no
+        return super().save(commit=commit)
 
 
 class ColonelRGBLightConfigForm(ColonelComponentForm):
-    output_pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    output_pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(output=True, native=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
@@ -705,6 +698,7 @@ class ColonelRGBLightConfigForm(ColonelComponentForm):
     )
 
     def save(self, commit=True):
+        self.instance.config['output_pin_no'] = self.cleaned_data['output_pin'].no
         if len(self.cleaned_data['order']) > 3:
             self.instance.config['has_white'] = True
         else:
@@ -714,62 +708,25 @@ class ColonelRGBLightConfigForm(ColonelComponentForm):
 
     def clean(self):
         super().clean()
-        if 'colonel' not in self.cleaned_data:
+        if not self.cleaned_data.get('colonel'):
             return self.cleaned_data
         if not self.cleaned_data.get('output_pin'):
             return self.cleaned_data
-        if self.instance.pk:
-            selected = self.instance.config.get('output_pin')
-        else:
-            self.cleaned_data['value_units'] = '%'
-            selected = None
-        output_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'], filters={'output': True, 'native': True},
-            selected=selected
-        )
-        if self.cleaned_data['output_pin'] not in output_pins:
-            self.add_error(
-                'output_pin',
-                "Sorry, but GPIO%d pin can not be used as output pin "
-                % self.cleaned_data['output_pin']
-            )
-            return self.cleaned_data
 
-        if 'controls' not in self.cleaned_data:
-            return self.cleaned_data
+        self._clean_pin('output_pin')
 
+        if not self.cleaned_data.get('controls'):
+            return self.cleaned_data
 
-        # TODO: Formset factory should return proper field value types instead of str type
-        for i, control in enumerate(self.cleaned_data['controls']):
-            for key, val in control.items():
-                if key in ('pin', 'touch_threshold'):
-                    self.cleaned_data['controls'][i][key] = int(val)
-                else:
-                    self.cleaned_data['controls'][i][key] = val
-
-        for i, control in enumerate(self.cleaned_data['controls']):
-            try:
-                selected = self.instance.config['controls'][i]['pin']
-            except:
-                selected = None
-            free_pins = get_available_gpio_pins(
-                self.cleaned_data['colonel'], filters={'input': True},
-                selected=selected
-            )
-            if control['pin'] not in free_pins:
-                self.add_error(
-                    'controls',
-                    "Sorry, but GPIO%d pin is occupied."
-                    % control['pin']
-                )
-                return
+        self._clean_controls()
 
         return self.cleaned_data
 
 
+
 class DualMotorValveForm(ColonelComponentForm):
-    open_pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    open_pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(output=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
@@ -786,8 +743,8 @@ class DualMotorValveForm(ColonelComponentForm):
         required=True, min_value=0.01, max_value=1000000000,
         help_text="Time in seconds to open."
     )
-    close_pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    close_pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(output=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
@@ -805,52 +762,30 @@ class DualMotorValveForm(ColonelComponentForm):
         help_text="Time in seconds to close."
     )
 
+
     def clean(self):
         super().clean()
-        if 'colonel' not in self.cleaned_data:
+        if not self.cleaned_data.get('colonel'):
             return self.cleaned_data
         if not self.cleaned_data.get('open_pin'):
             return self.cleaned_data
         if not self.cleaned_data.get('close_pin'):
             return self.cleaned_data
 
-        if self.instance.pk:
-            selected = self.instance.config.get('open_pin')
-        else:
-            selected = None
-        output_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'], filters={'output': True},
-            selected=selected
-        )
-        if self.cleaned_data['open_pin'] not in output_pins:
-            self.add_error(
-                'open_pin',
-                "Sorry, but GPIO%d pin can not be used as output pin "
-                % self.cleaned_data['open_pin']
-            )
-            return
+        self._clean_pin('open_pin')
+        self._clean_pin('close_pin')
 
-        if self.instance.pk:
-            selected = self.instance.config.get('close_pin')
-        else:
-            selected = None
-        output_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'], filters={'output': True},
-            selected=selected
-        )
-        if self.cleaned_data['close_pin'] not in output_pins:
-            self.add_error(
-                'close_pin',
-                "Sorry, but GPIO%d pin can not be used as output pin "
-                % self.cleaned_data['close_pin']
-            )
-            return
         return self.cleaned_data
 
+    def save(self, commit=True):
+        self.instance.config['open_pin_no'] = self.cleaned_data['open_pin'].no
+        self.instance.config['close_pin_no'] = self.cleaned_data['close_pin'].no
+        return super().save(commit=commit)
+
 
 class BlindsConfigForm(ColonelComponentForm):
-    open_pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    open_pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(output=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
@@ -863,8 +798,8 @@ class BlindsConfigForm(ColonelComponentForm):
     open_action = forms.ChoiceField(
         choices=(('HIGH', "HIGH"), ('LOW', "LOW")),
     )
-    close_pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    close_pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(output=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
@@ -922,47 +857,15 @@ class BlindsConfigForm(ColonelComponentForm):
 
     def clean(self):
         super().clean()
-        if 'colonel' not in self.cleaned_data:
+        if not self.cleaned_data.get('colonel'):
             return self.cleaned_data
         if not self.cleaned_data.get('open_pin'):
             return self.cleaned_data
         if not self.cleaned_data.get('close_pin'):
             return self.cleaned_data
 
-        if self.instance.pk:
-            selected = self.instance.config.get('open_pin')
-        else:
-            selected = None
-        output_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'],
-            filters={'output': True},
-            selected=selected
-        )
-        if self.cleaned_data['open_pin'] not in output_pins:
-            self.add_error(
-                'open_pin',
-                "Sorry, but GPIO%d pin can not be used as output pin "
-                % self.cleaned_data['open_pin']
-            )
-            return
-
-        if self.instance.pk:
-            selected = self.instance.config.get('close_pin')
-        else:
-            selected = None
-        output_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'],
-            filters={'output': True},
-            selected=selected
-        )
-        if self.cleaned_data['close_pin'] not in output_pins:
-            self.add_error(
-                'close_pin',
-                "Sorry, but GPIO%d pin can not be used as output pin "
-                % self.cleaned_data['close_pin']
-            )
-            return
-
+        self._clean_pin('open_pin')
+        self._clean_pin('close_pin')
 
         if 'controls' not in self.cleaned_data:
             return self.cleaned_data
@@ -981,38 +884,19 @@ class BlindsConfigForm(ColonelComponentForm):
                         self.add_error('controls', "Both must use the same control method.")
                         return self.cleaned_data
 
-
-        # TODO: Formset factory should return proper field value types instead of str type
-        for i, control in enumerate(self.cleaned_data['controls']):
-            for key, val in control.items():
-                if key in ('pin', 'touch_threshold'):
-                    self.cleaned_data['controls'][i][key] = int(val)
-                else:
-                    self.cleaned_data['controls'][i][key] = val
-
-        for i, control in enumerate(self.cleaned_data['controls']):
-            try:
-                selected = self.instance.config['controls'][i]['pin']
-            except:
-                selected = None
-            free_pins = get_available_gpio_pins(
-                self.cleaned_data['colonel'], filters={'input': True},
-                selected=selected
-            )
-            if control['pin'] not in free_pins:
-                self.add_error(
-                    'controls',
-                    "Sorry, but GPIO%d pin is occupied."
-                    % control['pin']
-                )
-                return
+        self._clean_controls()
 
         return self.cleaned_data
 
+    def save(self, commit=True):
+        self.instance.config['open_pin_no'] = self.cleaned_data['open_pin'].no
+        self.instance.config['close_pin_no'] = self.cleaned_data['close_pin'].no
+        return super().save(commit=commit)
+
 
 class BurglarSmokeDetectorConfigForm(ColonelComponentForm):
-    power_pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    power_pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(output=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
@@ -1025,8 +909,8 @@ class BurglarSmokeDetectorConfigForm(ColonelComponentForm):
     power_action = forms.ChoiceField(
         choices=(('HIGH', "HIGH"), ('LOW', "LOW")),
     )
-    sensor_pin = forms.TypedChoiceField(
-        coerce=int, choices=get_gpio_pins_choices,
+    sensor_pin = ColonelPinChoiceField(
+        queryset=ColonelPin.objects.filter(input=True),
         widget=autocomplete.ListSelect2(
             url='autocomplete-colonel-pins',
             forward=[
@@ -1053,49 +937,19 @@ class BurglarSmokeDetectorConfigForm(ColonelComponentForm):
 
     def clean(self):
         super().clean()
-        if 'colonel' not in self.cleaned_data:
+        if not self.cleaned_data.get('colonel'):
             return self.cleaned_data
         if 'sensor_pin' not in self.cleaned_data:
             return self.cleaned_data
         if 'power_pin' not in self.cleaned_data:
             return self.cleaned_data
 
-
-        if self.instance.pk:
-            selected = self.instance.config.get('power_pin')
-        else:
-            selected = None
-        output_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'], filters={'output': True},
-            selected=selected
-        )
-        if self.cleaned_data['power_pin'] not in output_pins:
-            self.add_error(
-                'output_pin',
-                "Sorry, but GPIO%d pin can not be used as output pin "
-                % self.cleaned_data['power_pin']
-            )
-            return self.cleaned_data
-
+        self._clean_pin('sensor_pin')
+        self._clean_pin('power_pin')
 
 
-        if self.instance.pk:
-            selected = self.instance.config.get('sensor_pin')
-        else:
-            selected = None
-        input_pins = get_available_gpio_pins(
-            self.cleaned_data['colonel'], filters={'input': True},
-            selected=selected
-        )
-        if self.cleaned_data['sensor_pin'] not in input_pins:
-            self.add_error(
-                'pin',
-                "Sorry, but GPIO%d pin can not be used as input pin "
-                % self.cleaned_data['pin']
-            )
-            return
-        if self.cleaned_data['sensor_pin'] > 100:
-            if self.cleaned_data['sensor_pin'] < 126:
+        if self.cleaned_data['sensor_pin'].no > 100:
+            if self.cleaned_data['sensor_pin'].no < 126:
                 if self.cleaned_data.get('sensor_pull') == 'HIGH':
                     self.add_error(
                         'sensor_pull',
@@ -1114,55 +968,43 @@ class BurglarSmokeDetectorConfigForm(ColonelComponentForm):
                         "if that's what you want to do."
                     )
         elif self.cleaned_data.get('sensor_pull') != 'FLOATING':
-            pins_available_for_pull = get_available_gpio_pins(
-                self.cleaned_data['colonel'], filters={'output': True},
-                selected=selected
-            )
-            if self.cleaned_data['sensor_pin'] not in pins_available_for_pull:
+            if not self.cleaned_data['sensor_pin'].output:
                 self.add_error(
-                    'pin',
-                    "Sorry, but GPIO%d pin does not have internal pull HIGH/LOW"
-                    " resistance capability" % self.cleaned_data['sensor_pin']
+                    'sensor_pin',
+                    f"Sorry, but {self.cleaned_data['sensor_pin']} "
+                    f"does not have internal pull HIGH/LOW"
+                    " resistance capability"
                 )
-                return
 
         return self.cleaned_data
 
+    def save(self, commit=True):
+        self.instance.config['sensor_pin_no'] = self.cleaned_data['sensor_pin'].no
+        self.instance.config['power_pin_no'] = self.cleaned_data['power_pin'].no
+        return super().save(commit=commit)
+
 
+class TTLockConfigForm(ColonelComponentForm):
+    pass
+
+    def clean(self):
+        if not self.instance or not self.instance.pk:
+            from .controllers import TTLock
+            other_lock = self.cleaned_data['colonel'].components.filter(
+                controller_uid=TTLock.uid
+            ).first()
+            if other_lock:
+                raise forms.ValidationError(
+                    f"Single Colonel can support single TTLock only.\n"
+                    f"You already have {other_lock} on this Colonel."
+                )
+        return self.cleaned_data
+
+
+    def save(self, commit=True):
+        obj = super(ColonelComponentForm, self).save(commit)
+        if commit:
+            self.cleaned_data['colonel'].components.add(obj)
+            self.cleaned_data['colonel'].save()
+        return obj
 
-#
-# class ColonelBLEClimateSensorConfigForm(
-#     ColonelComponentMixin, BaseComponentForm
-# ):
-#     colonel = forms.ModelChoiceField(queryset=Colonel.objects.all())
-#     ble_device = forms.ModelChoiceField(
-#         queryset=BLEDevice.objects.filter(
-#             type=BLE_DEVICE_TYPE_GOVEE_MULTISENSOR
-#         )
-#     )
-#     additional_fields = ('colonel', 'ble_device')
-#
-#     def __init__(self, *args, **kwargs):
-#         super().__init__(*args, **kwargs)
-#         qs = self.fields['ble_device'].queryset
-#         if self.instance.pk:
-#             self.fields['ble_device'].queryset = qs.filter(
-#                 Q(component__isnull=True) | Q(component=self.instance)
-#             )
-#         else:
-#             self.fields['ble_device'].queryset = qs.filter(component__isnull=True)
-#
-#     def clean(self):
-#         colonel_ble_devices = self.cleaned_data['colonel'].ble_devices.all()
-#         if self.cleaned_data['ble_device'] not in colonel_ble_devices:
-#             available_colonels = self.cleaned_data['ble_device'].colonels.all()
-#             self.add_error(
-#                 'ble_device',
-#                 _("This BLE device is available only on colonel%s: %s" %
-#                   (
-#                       's' if len(available_colonels) > 1 else '',
-#                       ', '.join([str(c) for c in available_colonels])
-#                   )
-#                 )
-#             )
-#         return self.cleaned_data