shimatta-kenkyusho/shimatta_kenkyusho/parts/forms.py

from django import forms
from django.core.exceptions import ValidationError
from parts import models as parts_models
from shimatta_modules.EngineeringNumberConverter import EngineeringNumberConverter

class MyTestForm(forms.Form):
    pass

class AddSubStorageForm(forms.Form):
    storage_name = forms.CharField(label="storage_name", initial='')
    responsible = forms.CharField(label='responsible_user')

class DeleteStockForm(forms.Form):
    stock_uuid = forms.UUIDField()

class EditWatermarkForm(forms.Form):
    stock_uuid = forms.UUIDField()
    watermark_active = forms.BooleanField(required=False) #If it is false, the webbrowser won't send it at all. Therefore we have to set it to required=False
    watermark = forms.IntegerField(min_value=0)

    def clean(self):
        cleaned_data = super().clean()
        id = cleaned_data.get("stock_uuid")
        
        if not id:
            raise ValidationError("No stock UUID given")

        stock = None
        try:
            stock = parts_models.Stock.objects.get(id=id)
        except:
            raise ValidationError("Stock with uuid %s does not exist" % (id))
        cleaned_data['stock'] = stock

        return cleaned_data

    def save(self):
        stock = self.cleaned_data['stock']
        active = self.cleaned_data['watermark_active']
        watermark = self.cleaned_data['watermark']

        if not active:
            watermark = -1

        stock.watermark = watermark
        stock.save()

class EditStockAmountForm(forms.Form):
    stock_uuid = forms.UUIDField()
    amount = forms.IntegerField(min_value=0)

    def clean(self):
        cleaned_data = super().clean()
        id = cleaned_data.get("stock_uuid")

        if not id:
            raise ValidationError("No stock UUID given")

        stock = None
        try:
            stock = parts_models.Stock.objects.get(id=id)
        except:
            raise ValidationError("Stock with uuid %s does not exist" % (id))
        cleaned_data['stock'] = stock

        return cleaned_data

    def save(self, increase: bool):
        stock = self.cleaned_data['stock']
        amount = self.cleaned_data['amount']

        if not increase:
            amount = -amount 

        return stock.atomic_increment(amount)

class AddStockForm(forms.Form):
    watermark_active = forms.BooleanField(required=False)
    watermark = forms.IntegerField(min_value=0, required=True, initial=0)
    amount = forms.IntegerField(min_value=0, required=True, initial=1)
    component_uuid = forms.UUIDField(required=True)

    def clean(self):
        cleaned_data = super().clean()

        id = cleaned_data.get('component_uuid')
        if not id:
            raise ValidationError('No valid component selected!')
        component = None
        try:
            component = parts_models.Component.objects.get(id=id)
        except:
            raise ValidationError("Invalid component selected!")
        cleaned_data['component'] = component

        return cleaned_data
    
    def save(self, storage):
        component = self.cleaned_data.get('component')
        amount = self.cleaned_data.get('amount')
        watermark = -1

        if self.cleaned_data.get('watermark_active'):
            watermark = self.cleaned_data.get('watermark')

        new_stock = parts_models.Stock.objects.create(storage=storage, component=component, watermark=watermark, amount=amount)
        new_stock.save()
        
class EditComponentForm(forms.Form):
    name = forms.CharField(required=True)
    datasheet_link = forms.CharField(max_length=300, required=False)
    description = forms.CharField(required=False, widget=forms.Textarea)
    
    # Look up these fields later. Will be autocompleted in UI
    manufacturer = forms.CharField(required=False, initial='')
    component_type = forms.CharField(required=False, label='Component Type', initial='')
    pref_distri = forms.CharField(required=False, label='Preferred Distributor', initial='')
    package = forms.CharField(required=False, initial='')

    image = forms.ImageField(required=False)

    def __init__(self, *args, instance=None, **kwargs):
        super().__init__(*args, **kwargs)

        self.instance = instance
        if instance:
            self.fields['name'].initial = instance.name
            self.fields['datasheet_link'].initial = instance.datasheet_link
            if instance.component_type:
                self.fields['component_type'].initial = instance.component_type.class_name
            self.fields['description'].initial = instance.description
            if instance.manufacturer:
                self.fields['manufacturer'].initial = instance.manufacturer.name
            if instance.package:
                self.fields['package'].initial = instance.package.name
            if instance.pref_distri:
                self.fields['pref_distri'].initial = instance.pref_distri.name
            self.fields['image'].initial = instance.image

    def clean_component_type(self):
        data = self.cleaned_data['component_type'].strip()
        
        if len(data) == 0:
            self.cleaned_data['component_type_object'] = None
            return

        try:
            self.cleaned_data['component_type_object'] = parts_models.ComponentType.objects.get(class_name=data)
        except:
            raise ValidationError('Invalid Component Type')
    
    def clean_manufacturer(self):
        data = self.cleaned_data['manufacturer'].strip()
        
        if len(data) == 0:
            self.cleaned_data['manufacturer_object'] = None
            return
        try:
            self.cleaned_data['manufacturer_object'] = parts_models.Manufacturer.objects.get(name=data)
        except:
            raise ValidationError('Invalid Manufacturer')

    def clean_pref_distri(self):
        data = self.cleaned_data['pref_distri'].strip()
        
        if len(data) == 0:
            self.cleaned_data['pref_distri_object'] = None
            return
        try:
            self.cleaned_data['pref_distri_object'] = parts_models.Distributor.objects.get(name=data)
        except:
            raise ValidationError('Invalid Distributor')

    def clean_package(self):
        data = self.cleaned_data['package'].strip()
        
        if len(data) == 0:
            self.cleaned_data['package_object'] = None
            return
        try:
            self.cleaned_data['package_object'] = parts_models.Package.objects.get(name=data)
        except:
            raise ValidationError('Invalid Package')


    def save(self):
        if self.instance is None:
            self.instance = parts_models.Component.objects.create()

        self.instance.name = self.cleaned_data['name']
        self.instance.datasheet_link = self.cleaned_data['datasheet_link']
        self.instance.description = self.cleaned_data['description']
        
        if bool(self.cleaned_data['image']) is False:
            self.instance.image = None
        else:
            self.instance.image = self.cleaned_data['image']

        self.instance.manufacturer = self.cleaned_data['manufacturer_object']
        self.instance.pref_distri = self.cleaned_data['pref_distri_object']
        self.instance.package = self.cleaned_data['package_object']
        self.instance.component_type = self.cleaned_data['component_type_object']
        self.instance.save()

class EditComponentParameterForm(forms.Form):
    parameter_type = forms.CharField() # This must come first. Do not change the order of these elements!
    value = forms.CharField()

    def __init__(self, *args, **kwargs):

        init_values = kwargs.get('initial', None)
        if init_values is not None:            
            if isinstance(init_values['parameter_type'], parts_models.ComponentParameterType):
                type_instance = init_values['parameter_type']
                self.parameter_type_object = type_instance
                kwargs['initial']['parameter_type'] = init_values['parameter_type'].parameter_name
                if isinstance(init_values['value'], int) or isinstance(init_values['value'], float):
                    if type_instance.engineering_unit:
                        (num, prefix) = EngineeringNumberConverter.number_to_engineering(init_values['value'], False)
                        kwargs['initial']['value'] = f'{num} {prefix}'
                    elif type_instance.it_unit:
                        (num, prefix) = EngineeringNumberConverter.number_to_engineering(init_values['value'], True)
                        kwargs['initial']['value'] = f'{num} {prefix}'

        super().__init__(*args, **kwargs)

    def clean_parameter_type(self):
        data = self.cleaned_data['parameter_type']

        param_instance = None
        try:
            param_instance = parts_models.ComponentParameterType.objects.get(parameter_name=data)
        except:
            raise ValidationError(f'Component Parameter Type {data} is not defined')
        
        self.cleaned_data['parameter_type_object'] = param_instance
        return data

    def clean_value(self):
        parameter_type = self.cleaned_data.get('parameter_type_object', None)
        value_data = self.cleaned_data['value']

        if parameter_type is None:
            raise ValidationError('Cannot convert value for unknown parameter type')

        processed_value = None

        if parameter_type.it_unit or parameter_type.engineering_unit:
            try:
                processed_value = EngineeringNumberConverter.engineering_to_number(value_data)
            except:
                raise ValidationError(f'Cannot not convert Value "{value_data}" to a number')
        elif parameter_type.freetext_parameter:
            processed_value = value_data
        else:
            try:
                processed_value = float(value_data)
            except:
                raise ValidationError(f'"{value_data}" is not a valid number')

        self.cleaned_data['processed_value'] = processed_value

        return value_data