350 lines
13 KiB
Python
350 lines
13 KiB
Python
from django import forms
|
|
from django.contrib.auth import get_user_model
|
|
from django.core.exceptions import ValidationError
|
|
from django.forms import widgets
|
|
from parts import models as parts_models
|
|
from shimatta_modules.EngineeringNumberConverter import EngineeringNumberConverter
|
|
import uuid
|
|
from django.urls import reverse
|
|
from .qr_parser import QrCodeValidator
|
|
|
|
|
|
from crispy_forms.helper import FormHelper
|
|
from crispy_forms.layout import Layout, Row, Column
|
|
|
|
class AutoCompleteWidget(widgets.Input):
|
|
template_name = 'widgets/autocomplete-foreign-key.html'
|
|
|
|
def __init__(self, api_search_url, image_field_name, foreign_model, name_field_name, prepend=None, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.image_field_name = image_field_name
|
|
self.foreign_model = foreign_model
|
|
self.api_search_url = api_search_url
|
|
self.name_field_name = name_field_name
|
|
self.prepend = prepend
|
|
|
|
def get_context(self, name, value, attrs):
|
|
context = super().get_context(name, value, attrs)
|
|
if value is not None:
|
|
try:
|
|
try:
|
|
my_id = uuid.UUID(value)
|
|
except:
|
|
my_id = int(value)
|
|
instance = self.foreign_model.objects.get(id=my_id)
|
|
except Exception as ex:
|
|
instance = None
|
|
else:
|
|
instance = None
|
|
|
|
image = None
|
|
if instance is not None and self.image_field_name is not None:
|
|
image = getattr(instance, self.image_field_name)
|
|
|
|
display_name = None
|
|
if instance:
|
|
display_name = getattr(instance, self.name_field_name)
|
|
|
|
context['custom'] = {
|
|
'search_url': reverse(self.api_search_url),
|
|
'image_field_name': self.image_field_name,
|
|
'current_instance': instance,
|
|
'image': image,
|
|
'name_field_name': self.name_field_name,
|
|
'prepend': self.prepend,
|
|
'name': display_name,
|
|
}
|
|
return context
|
|
|
|
class AutocompleteForeingKeyField(forms.UUIDField):
|
|
def __init__(self,
|
|
foreign_model=None,
|
|
api_search_url=None,
|
|
image_field_name='image',
|
|
name_field_name='name',
|
|
prepend=None,
|
|
**kwargs):
|
|
super().__init__(**kwargs)
|
|
self.widget = AutoCompleteWidget(api_search_url,
|
|
image_field_name,
|
|
foreign_model,
|
|
name_field_name,
|
|
prepend)
|
|
self.foreign_model = foreign_model
|
|
|
|
|
|
def clean(self, value):
|
|
try:
|
|
pre_cleaned_uuid = super().clean(value)
|
|
except Exception as ex:
|
|
try:
|
|
pre_cleaned_uuid = int(value)
|
|
except:
|
|
raise ex
|
|
if pre_cleaned_uuid is None and not self.required:
|
|
return None
|
|
try:
|
|
obj = self.foreign_model.objects.get(id=pre_cleaned_uuid)
|
|
except self.foreign_model.DoesNotExist:
|
|
raise ValidationError('Given element does not exist')
|
|
return obj
|
|
|
|
class MyTestForm(forms.Form):
|
|
pass
|
|
|
|
class ChangeStorageForm(forms.Form):
|
|
storage_name = forms.CharField(label="Name", initial='')
|
|
verbose_name = forms.CharField(label="Verbose Name", initial='', required=False)
|
|
responsible = AutocompleteForeingKeyField(api_search_url='user-list',
|
|
image_field_name=None,
|
|
name_field_name='username',
|
|
foreign_model=get_user_model(),
|
|
prepend='@')
|
|
|
|
is_template = forms.BooleanField(label='is_template', required=False)
|
|
|
|
class AddSubStorageForm(ChangeStorageForm):
|
|
template = AutocompleteForeingKeyField(api_search_url='storage-template-list',
|
|
image_field_name=None,
|
|
foreign_model=parts_models.Storage,
|
|
required=False)
|
|
|
|
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)
|
|
lot = forms.CharField(max_length=255, required=False)
|
|
|
|
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, lot=self.cleaned_data['lot'])
|
|
new_stock.save()
|
|
|
|
class ComponentForm(forms.ModelForm):
|
|
manufacturer = AutocompleteForeingKeyField(api_search_url='manufacturer-list', foreign_model=parts_models.Manufacturer, required=False)
|
|
component_type = AutocompleteForeingKeyField(api_search_url='componenttype-list', foreign_model=parts_models.ComponentType, name_field_name='class_name', required=False, image_field_name=None)
|
|
package = AutocompleteForeingKeyField(api_search_url='package-list', foreign_model=parts_models.Package, required=False)
|
|
pref_distri = AutocompleteForeingKeyField(api_search_url='distributor-list', foreign_model=parts_models.Distributor, required=False)
|
|
class Meta:
|
|
model = parts_models.Component
|
|
fields = '__all__'
|
|
|
|
class ImportComponentForm(forms.Form):
|
|
csv_file = forms.FileField(label="CSV File")
|
|
|
|
class PackageForm(forms.ModelForm):
|
|
class Meta:
|
|
model = parts_models.Package
|
|
fields = '__all__'
|
|
|
|
class DistributorForm(forms.ModelForm):
|
|
class Meta:
|
|
model = parts_models.Distributor
|
|
fields = '__all__'
|
|
class ManufacturerForm(forms.ModelForm):
|
|
class Meta:
|
|
model = parts_models.Manufacturer
|
|
fields = '__all__'
|
|
|
|
class DistributorNumberCreateForm(forms.ModelForm):
|
|
distributor = AutocompleteForeingKeyField(api_search_url='distributor-list', foreign_model=parts_models.Distributor, required=True)
|
|
|
|
class Meta:
|
|
model = parts_models.DistributorNum
|
|
fields = ['distributor', 'distributor_part_number']
|
|
|
|
class DistributorNumberDeleteForm(forms.Form):
|
|
distributor_num = forms.UUIDField(required=True)
|
|
|
|
def clean_distributor_num(self):
|
|
my_uuid = self.cleaned_data['distributor_num']
|
|
try:
|
|
distributor_number = parts_models.DistributorNum.objects.get(id=my_uuid)
|
|
except:
|
|
raise ValidationError('distributor number invalid')
|
|
return distributor_number
|
|
|
|
class ComponentParameterDeleteForm(forms.Form):
|
|
param_num = forms.UUIDField(required=True)
|
|
|
|
def clean_param_num(self):
|
|
my_uuid = self.cleaned_data['param_num']
|
|
try:
|
|
param = parts_models.ComponentParameter.objects.get(id=my_uuid)
|
|
except:
|
|
raise ValidationError('Parameter Number Invalid')
|
|
return param
|
|
|
|
class AdvancedComponentSearchForm(forms.Form):
|
|
name = forms.CharField(max_length=255, label='Component Name', required=False)
|
|
package = AutocompleteForeingKeyField(required=False, api_search_url='package-list', foreign_model=parts_models.Package)
|
|
package_pin_count = forms.IntegerField(min_value=0, label='Pin Count', required=False)
|
|
distributor_num = forms.CharField(max_length=100, label='Distributor Part Number', required=False)
|
|
distributor = AutocompleteForeingKeyField(required=False, api_search_url='distributor-list', foreign_model=parts_models.Distributor)
|
|
component_type = AutocompleteForeingKeyField(required=False, api_search_url='componenttype-list', foreign_model=parts_models.ComponentType, image_field_name=None, name_field_name='class_name')
|
|
manufacturer = AutocompleteForeingKeyField(required=False, api_search_url='manufacturer-list', foreign_model=parts_models.Manufacturer)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.helper = FormHelper()
|
|
self.helper.form_tag = False
|
|
self.helper.layout = Layout(
|
|
Row(
|
|
Column('name'),
|
|
),
|
|
Row(
|
|
Column('package'),
|
|
Column('package_pin_count'),
|
|
),
|
|
Row(
|
|
Column('component_type'),
|
|
Column('manufacturer'),
|
|
),
|
|
Row(
|
|
Column('distributor'),
|
|
Column('distributor_num'),
|
|
),
|
|
)
|
|
|
|
class ComponentParameterSearchForm(forms.Form):
|
|
parameter = AutocompleteForeingKeyField(required=True, foreign_model=parts_models.ComponentParameterType, api_search_url='componentparametertype-list', image_field_name=None, name_field_name='parameter_name')
|
|
value = forms.CharField(max_length=100, required=False)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.helper = FormHelper()
|
|
self.helper.form_tag = False
|
|
self.helper.layout = Layout(
|
|
Row(
|
|
Column('parameter'),
|
|
Column('value')
|
|
)
|
|
)
|
|
class ComponentParameterCreateForm(forms.Form):
|
|
parameter_type = AutocompleteForeingKeyField(required=True, foreign_model=parts_models.ComponentParameterType, api_search_url='componentparametertype-list', image_field_name=None, name_field_name='descriptive_name')
|
|
value = forms.CharField(required=True, max_length=256)
|
|
|
|
def clean(self):
|
|
data = super().clean()
|
|
ptype = data.get('parameter_type')
|
|
value = data.get('value')
|
|
|
|
if not ptype:
|
|
raise ValidationError('No valid parameter type selected')
|
|
|
|
if not value:
|
|
raise ValidationError('No valid parameter value')
|
|
|
|
if ptype.parameter_type == 'E' or ptype.parameter_type == 'I' or ptype.parameter_type == 'N':
|
|
try:
|
|
number = EngineeringNumberConverter.engineering_to_number(value)
|
|
except:
|
|
raise ValidationError('Cannot convert value to number')
|
|
data['number_value'] = number
|
|
else:
|
|
pass
|
|
|
|
def save(self, component):
|
|
param_type = self.cleaned_data['parameter_type']
|
|
if param_type.parameter_type == 'F':
|
|
text_value = self.cleaned_data['value']
|
|
value = 0
|
|
else:
|
|
text_value = ''
|
|
value = self.cleaned_data['number_value']
|
|
parts_models.ComponentParameter.objects.create(parameter_type=param_type, component=component, value=value, text_value=text_value)
|
|
|
|
class QrSearchForm(forms.Form):
|
|
my_qr_validator = QrCodeValidator()
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
|
|
|
|
qr_search = forms.CharField(label='qr_search', validators=[my_qr_validator]) |