forms.py
426 lines
| 17.3 KiB
| text/x-python
|
PythonLexer
|
r45 | import os | |
|
r23 | import json | |
|
r13 | from django import forms | |
|
r45 | from django.utils.safestring import mark_safe | |
from apps.main.models import Device | |||
from apps.main.forms import add_empty_choice | |||
|
r328 | from .models import RCConfiguration, RCLine, RCLineType, RCLineCode, RCClock | |
|
r107 | from .widgets import KmUnitWidget, KmUnitHzWidget, KmUnitDcWidget, UnitKmWidget, DefaultWidget, CodesWidget, HiddenWidget, HCheckboxSelectMultiple | |
|
r25 | ||
|
r149 | def create_choices_from_model(model, conf_id, all_choice=False): | |
|
r172 | ||
|
r25 | if model=='RCLine': | |
instance = RCConfiguration.objects.get(pk=conf_id) | |||
|
r107 | choices = [(line.pk, line.get_name()) for line in instance.get_lines(line_type__name='tx')] | |
|
r149 | if all_choice: | |
choices = add_empty_choice(choices, label='All') | |||
|
r25 | else: | |
instance = globals()[model] | |||
|
r45 | choices = instance.objects.all().values_list('pk', 'name') | |
|
r172 | ||
|
r79 | return choices | |
|
r45 | ||
class ExtFileField(forms.FileField): | |||
""" | |||
Same as forms.FileField, but you can specify a file extension whitelist. | |||
>>> from django.core.files.uploadedfile import SimpleUploadedFile | |||
>>> | |||
>>> t = ExtFileField(ext_whitelist=(".pdf", ".txt")) | |||
>>> | |||
>>> t.clean(SimpleUploadedFile('filename.pdf', 'Some File Content')) | |||
>>> t.clean(SimpleUploadedFile('filename.txt', 'Some File Content')) | |||
>>> | |||
>>> t.clean(SimpleUploadedFile('filename.exe', 'Some File Content')) | |||
Traceback (most recent call last): | |||
... | |||
ValidationError: [u'Not allowed filetype!'] | |||
""" | |||
def __init__(self, *args, **kwargs): | |||
extensions = kwargs.pop("extensions") | |||
self.extensions = [i.lower() for i in extensions] | |||
super(ExtFileField, self).__init__(*args, **kwargs) | |||
def clean(self, *args, **kwargs): | |||
data = super(ExtFileField, self).clean(*args, **kwargs) | |||
filename = data.name | |||
ext = os.path.splitext(filename)[1] | |||
ext = ext.lower() | |||
if ext not in self.extensions: | |||
|
r79 | raise forms.ValidationError('Not allowed file type: %s' % ext) | |
|
r172 | ||
|
r45 | ||
|
r13 | class RCConfigurationForm(forms.ModelForm): | |
|
r172 | ||
|
r45 | def __init__(self, *args, **kwargs): | |
super(RCConfigurationForm, self).__init__(*args, **kwargs) | |||
|
r172 | ||
|
r45 | instance = getattr(self, 'instance', None) | |
|
r172 | ||
|
r45 | if instance and instance.pk: | |
|
r172 | ||
|
r45 | devices = Device.objects.filter(device_type__name='rc') | |
|
r79 | if instance.experiment: | |
|
r107 | self.fields['experiment'].widget.attrs['read_only'] = True | |
|
r172 | #self.fields['experiment'].widget.choices = [(instance.experiment.id, instance.experiment)] | |
|
r45 | self.fields['device'].widget.choices = [(device.id, device) for device in devices] | |
|
r79 | self.fields['ipp'].widget = KmUnitHzWidget(attrs={'km2unit':instance.km2unit}) | |
self.fields['clock'].widget.attrs['readonly'] = True | |||
self.fields['time_before'].label = mark_safe(self.fields['time_before'].label) | |||
self.fields['time_after'].label = mark_safe(self.fields['time_after'].label) | |||
|
r172 | ||
|
r85 | if 'initial' in kwargs and 'experiment' in kwargs['initial'] and kwargs['initial']['experiment'] not in (0, '0'): | |
|
r116 | self.fields['experiment'].widget.attrs['readonly'] = True | |
|
r172 | ||
|
r13 | class Meta: | |
model = RCConfiguration | |||
|
r328 | exclude = ('type', 'parameters', 'status', 'total_units', 'mix', 'author', 'hash', 'clock_in') | |
|
r23 | ||
|
r79 | def clean(self): | |
form_data = super(RCConfigurationForm, self).clean() | |||
|
r172 | ||
|
r79 | if 'clock_divider' in form_data: | |
if form_data['clock_divider']<1: | |||
self.add_error('clock_divider', 'Invalid Value') | |||
|
r264 | #else: | |
# if form_data['ipp']*(20./3*(form_data['clock_in']/form_data['clock_divider']))%10!=0: | |||
# self.add_error('ipp', 'Invalid IPP units={}'.format(form_data['ipp']*(20./3*(form_data['clock_in']/form_data['clock_divider'])))) | |||
|
r172 | ||
|
r79 | return form_data | |
|
r107 | ||
|
r316 | def save(self, *args, **kwargs): | |
conf = super(RCConfigurationForm, self).save(*args, **kwargs) | |||
|
r332 | clk = RCClock.objects.filter(rc_configuration=conf).first() | |
if clk: | |||
conf.clock_in = clk.frequency | |||
|
r116 | conf.total_units = conf.ipp*conf.ntx*conf.km2unit | |
conf.save() | |||
return conf | |||
|
r172 | ||
|
r107 | ||
class RCMixConfigurationForm(forms.Form): | |||
|
r172 | ||
|
r107 | clock_in = forms.CharField(widget=forms.HiddenInput()) | |
clock_divider = forms.CharField(widget=forms.HiddenInput()) | |||
name = forms.CharField() | |||
experiment = forms.ChoiceField() | |||
|
r112 | mode = forms.ChoiceField(widget=forms.RadioSelect(), | |
|
r172 | choices=[(0, 'Parallel'), (1, 'Sequence')], | |
|
r112 | initial=0) | |
|
r107 | operation = forms.ChoiceField(widget=forms.RadioSelect(), | |
|
r172 | choices=[(0, 'OR'), (1, 'XOR'), (2, 'AND'), (3, 'NAND')], | |
|
r107 | initial=1) | |
delay = forms.CharField() | |||
|
r316 | mask = forms.MultipleChoiceField( | |
choices=[(0, 'L1'),(1, 'L2'),(2, 'L3'),(3, 'L4'),(4, 'L5'),(5, 'L6'),(6, 'L7'),(7, 'L8'), | |||
(8, 'L9'),(9, 'L10'),(10, 'L11'),(11, 'L12'),(12, 'L13'),(13, 'L14'),(14, 'L15'),(15, 'L16')], | |||
widget=HCheckboxSelectMultiple()) | |||
|
r107 | result = forms.CharField(required=False, | |
widget=forms.Textarea(attrs={'readonly':True, 'rows':5, 'class':'tabuled'})) | |||
|
r172 | ||
|
r107 | def __init__(self, *args, **kwargs): | |
confs = kwargs.pop('confs', []) | |||
if confs: | |||
km2unit = confs[0].km2unit | |||
clock_in = confs[0].clock_in | |||
clock_divider = confs[0].clock_divider | |||
else: | |||
km2unit = clock_in = clock_divider = 0 | |||
super(RCMixConfigurationForm, self).__init__(*args, **kwargs) | |||
self.fields['experiment'].choices = [(conf.pk, '{} | {}'.format(conf.pk, conf.name)) for conf in confs] | |||
self.fields['delay'].widget = KmUnitWidget(attrs = {'km2unit':km2unit}) | |||
self.fields['clock_in'].initial = clock_in | |||
self.fields['clock_divider'].initial = clock_divider | |||
|
r172 | ||
|
r23 | class RCLineForm(forms.ModelForm): | |
|
r172 | ||
|
r25 | def __init__(self, *args, **kwargs): | |
self.extra_fields = kwargs.pop('extra_fields', []) | |||
super(RCLineForm, self).__init__(*args, **kwargs) | |||
|
r172 | ||
|
r79 | if 'initial' in kwargs and 'line_type' in kwargs['initial']: | |
line_type = RCLineType.objects.get(pk=kwargs['initial']['line_type']) | |||
|
r172 | ||
|
r79 | if 'code_id' in kwargs['initial']: | |
model_initial = kwargs['initial']['code_id'] | |||
else: | |||
model_initial = 0 | |||
|
r172 | ||
|
r79 | params = json.loads(line_type.params) | |
|
r172 | ||
|
r79 | for label, value in self.extra_fields.items(): | |
if label=='params': | |||
continue | |||
|
r172 | ||
|
r79 | if 'model' in params[label]: | |
|
r172 | self.fields[label] = forms.ChoiceField(choices=create_choices_from_model(params[label]['model'], | |
|
r79 | kwargs['initial']['rc_configuration']), | |
initial=model_initial) | |||
|
r172 | ||
|
r79 | else: | |
if label=='codes' and 'code_id' in kwargs['initial']: | |||
self.fields[label] = forms.CharField(initial=RCLineCode.objects.get(pk=kwargs['initial']['code_id']).codes) | |||
else: | |||
self.fields[label] = forms.CharField(initial=value['value']) | |||
|
r172 | ||
|
r79 | if label=='codes': | |
self.fields[label].widget = CodesWidget() | |||
|
r172 | ||
|
r79 | if self.data: | |
line_type = RCLineType.objects.get(pk=self.data['line_type']) | |||
|
r172 | ||
|
r79 | if 'code_id' in self.data: | |
model_initial = self.data['code_id'] | |||
else: | |||
model_initial = 0 | |||
|
r172 | ||
|
r79 | params = json.loads(line_type.params) | |
|
r172 | ||
|
r79 | for label, value in self.extra_fields.items(): | |
if label=='params': | |||
|
r45 | continue | |
|
r172 | ||
|
r79 | if 'model' in params[label]: | |
|
r172 | self.fields[label] = forms.ChoiceField(choices=create_choices_from_model(params[label]['model'], | |
|
r79 | self.data['rc_configuration']), | |
initial=model_initial) | |||
|
r172 | ||
|
r25 | else: | |
|
r79 | if label=='codes' and 'code' in self.data: | |
|
r172 | self.fields[label] = forms.CharField(initial=self.data['codes']) | |
|
r79 | else: | |
self.fields[label] = forms.CharField(initial=self.data[label]) | |||
|
r172 | ||
|
r79 | if label=='codes': | |
self.fields[label].widget = CodesWidget() | |||
|
r172 | ||
|
r23 | class Meta: | |
model = RCLine | |||
fields = ('rc_configuration', 'line_type', 'channel') | |||
widgets = { | |||
'channel': forms.HiddenInput(), | |||
} | |||
|
r172 | ||
|
r79 | def clean(self): | |
|
r172 | ||
|
r79 | form_data = self.cleaned_data | |
|
r172 | if 'code' in self.data and self.data['TX_ref']=="0": | |
|
r79 | self.add_error('TX_ref', 'Choose a valid TX reference') | |
|
r172 | ||
|
r142 | if RCLineType.objects.get(pk=self.data['line_type']).name=='mix': | |
self.add_error('line_type', 'Invalid Line type') | |||
|
r172 | ||
|
r79 | return form_data | |
|
r172 | ||
def save(self): | |||
|
r23 | line = super(RCLineForm, self).save() | |
|
r172 | ||
|
r23 | #auto add channel | |
line.channel = RCLine.objects.filter(rc_configuration=line.rc_configuration).count()-1 | |||
|
r172 | ||
|
r23 | #auto add position for TX, TR & CODE | |
|
r45 | if line.line_type.name in ('tx', ): | |
|
r23 | line.position = RCLine.objects.filter(rc_configuration=line.rc_configuration, line_type=line.line_type).count()-1 | |
|
r172 | ||
|
r25 | #save extra fields in params | |
|
r23 | params = {} | |
|
r79 | for label, value in self.extra_fields.items(): | |
if label=='params': | |||
|
r45 | params['params'] = [] | |
|
r79 | elif label=='codes': | |
params[label] = [s for s in self.data[label].split('\r\n') if s] | |||
|
r45 | else: | |
|
r79 | params[label] = self.data[label] | |
|
r23 | line.params = json.dumps(params) | |
line.save() | |||
return | |||
|
r172 | ||
|
r23 | class RCLineViewForm(forms.Form): | |
|
r172 | ||
|
r23 | def __init__(self, *args, **kwargs): | |
|
r172 | ||
|
r23 | extra_fields = kwargs.pop('extra_fields') | |
|
r45 | line = kwargs.pop('line') | |
subform = kwargs.pop('subform', False) | |||
|
r23 | super(RCLineViewForm, self).__init__(*args, **kwargs) | |
|
r172 | ||
|
r79 | if subform: | |
params = json.loads(line.line_type.params)['params'] | |||
else: | |||
params = json.loads(line.line_type.params) | |||
|
r172 | ||
|
r23 | for label, value in extra_fields.items(): | |
|
r172 | ||
|
r45 | if label=='params': | |
continue | |||
|
r25 | if 'ref' in label: | |
|
r45 | if value in (0, '0'): | |
value = 'All' | |||
else: | |||
value = RCLine.objects.get(pk=value).get_name() | |||
|
r79 | elif label=='code': | |
|
r25 | value = RCLineCode.objects.get(pk=value).name | |
|
r172 | ||
self.fields[label] = forms.CharField(initial=value) | |||
|
r45 | if 'widget' in params[label]: | |
|
r79 | km2unit = line.rc_configuration.km2unit | |
|
r45 | if params[label]['widget']=='km': | |
|
r79 | self.fields[label].widget = KmUnitWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True}) | |
elif params[label]['widget']=='unit': | |||
self.fields[label].widget = UnitKmWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True}) | |||
elif params[label]['widget']=='dc': | |||
self.fields[label].widget = KmUnitDcWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True}) | |||
elif params[label]['widget']=='codes': | |||
self.fields[label].widget = CodesWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True}) | |||
|
r45 | else: | |
|
r79 | self.fields[label].widget = DefaultWidget(attrs={'disabled':True}) | |
|
r172 | ||
|
r45 | class RCLineEditForm(forms.ModelForm): | |
|
r172 | ||
|
r25 | def __init__(self, *args, **kwargs): | |
|
r341 | print("RCLineEditForm") | |
|
r172 | ||
|
r79 | extra_fields = kwargs.pop('extra_fields', []) | |
conf = kwargs.pop('conf', False) | |||
line = kwargs.pop('line') | |||
subform = kwargs.pop('subform', False) | |||
|
r172 | ||
|
r25 | super(RCLineEditForm, self).__init__(*args, **kwargs) | |
|
r172 | ||
|
r79 | if subform is not False: | |
params = json.loads(line.line_type.params)['params'] | |||
count = subform | |||
else: | |||
params = json.loads(line.line_type.params) | |||
|
r172 | count = -1 | |
|
r79 | for label, value in extra_fields.items(): | |
|
r172 | ||
|
r79 | if label in ('params',): | |
continue | |||
if 'help' in params[label]: | |||
help_text = params[label]['help'] | |||
else: | |||
help_text = '' | |||
|
r172 | ||
|
r149 | if 'model' in params[label]: | |
if line.line_type.name=='tr': | |||
all_choice = True | |||
else: | |||
all_choice = False | |||
|
r341 | #print("'name':'%s|%s|%s'" % (count, line.id, label)) | |
aux_name = '%s|%s|%s' % (count, line.id, label) | |||
print(aux_name) | |||
print(label) | |||
self.fields[aux_name] = forms.ChoiceField(choices=create_choices_from_model(params[label]['model'], conf.id, all_choice=all_choice), | |||
|
r79 | initial=value, | |
|
r341 | label=label, | |
widget=forms.Select(attrs={'name':'%s|%s|%s' % (count, line.id, label)}), #No trabaja con attrs esta versión de django 2.0 hacia adelante | |||
#widget=forms.Select(attrs={'name':'HOLA'}), #No trabaja con attrs esta versión de django 2.0 hacia adelante | |||
|
r79 | help_text=help_text) | |
|
r172 | ||
else: | |||
|
r79 | self.fields[label] = forms.CharField(initial=value, help_text=help_text) | |
|
r172 | ||
if label in ('code', ): | |||
self.fields[label].widget = HiddenWidget(attrs={'name':'%s|%s|%s' % (count, line.id, label)}) | |||
|
r79 | elif 'widget' in params[label]: | |
|
r172 | km2unit = line.rc_configuration.km2unit | |
if params[label]['widget']=='km': | |||
|
r79 | self.fields[label].widget = KmUnitWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)}) | |
elif params[label]['widget']=='unit': | |||
self.fields[label].widget = UnitKmWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)}) | |||
elif params[label]['widget']=='dc': | |||
self.fields[label].widget = KmUnitDcWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)}) | |||
elif params[label]['widget']=='codes': | |||
|
r172 | self.fields[label].widget = CodesWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)}) | |
|
r158 | else: | |
self.fields[label].widget = DefaultWidget(attrs={'line':line, 'name':'%s|%s|%s' % (count, line.id, label)}) | |||
|
r172 | ||
|
r45 | class Meta: | |
model = RCLine | |||
exclude = ('rc_configuration', 'line_type', 'channel', 'position', 'params', 'pulses') | |||
|
r172 | ||
|
r45 | class RCSubLineEditForm(forms.Form): | |
|
r172 | ||
|
r45 | def __init__(self, *args, **kwargs): | |
|
r341 | print("RCSubLineEditForm") | |
|
r45 | extra_fields = kwargs.pop('extra_fields') | |
count = kwargs.pop('count') | |||
line = kwargs.pop('line') | |||
super(RCSubLineEditForm, self).__init__(*args, **kwargs) | |||
|
r172 | for label, value in extra_fields.items(): | |
|
r45 | self.fields[label] = forms.CharField(initial=value, | |
widget=forms.TextInput(attrs={'name':'%s|%s|%s' % (count, line, label)})) | |||
|
r341 | ||
|
r45 | ||
class RCImportForm(forms.Form): | |||
|
r172 | ||
|
r45 | file_name = ExtFileField(extensions=['.racp', '.json', '.dat']) | |
|
r172 | ||
class RCLineCodesForm(forms.ModelForm): | |||
|
r79 | def __init__(self, *args, **kwargs): | |
super(RCLineCodesForm, self).__init__(*args, **kwargs) | |||
|
r172 | ||
|
r79 | if 'initial' in kwargs: | |
self.fields['code'] = forms.ChoiceField(choices=RCLineCode.objects.all().values_list('pk', 'name'), | |||
initial=kwargs['initial']['code']) | |||
if 'instance' in kwargs: | |||
self.fields['code'] = forms.ChoiceField(choices=RCLineCode.objects.all().values_list('pk', 'name'), | |||
initial=kwargs['instance'].pk) | |||
|
r172 | ||
|
r79 | self.fields['codes'].widget = CodesWidget() | |
|
r172 | ||
|
r79 | class Meta: | |
model = RCLineCode | |||
exclude = ('name',) | |||
|
r328 | ||
class RCClockForm(forms.ModelForm): | |||
def __init__(self, *args, **kwargs): | |||
super(RCClockForm, self).__init__(*args, **kwargs) | |||
instance = getattr(self, 'instance', None) | |||
if instance is not None and instance.mode: | |||
self.fields['multiplier'].widget.attrs['readonly'] = True | |||
self.fields['divisor'].widget.attrs['readonly'] = True | |||
self.fields['reference'].widget.attrs['readonly'] = True | |||
class Meta: | |||
model = RCClock | |||
exclude = ('rc_configuration',) | |||
def clean(self): | |||
form_data = self.cleaned_data | |||
if form_data['mode'] is True and float(form_data['frequency']) not in (60., 55.): | |||
self.add_error('frequency', 'Only 60 and 55 are valid values in auto mode') | |||
elif form_data['mode'] is False: | |||
if form_data['reference']==0 and not 24<=form_data['multiplier']<=36: | |||
self.add_error('multiplier', 'For 25MHz, valid values are between 24 and 36') | |||
elif form_data['reference']==1 and not 60<=form_data['multiplier']<=90: | |||
self.add_error('multiplier', 'For 10MHz, valid values are between 60 and 90') | |||
return form_data |