@@ -1,115 +1,115 | |||||
1 | import os |
|
1 | import os | |
2 |
|
2 | |||
3 | from django import forms |
|
3 | from django import forms | |
4 | from apps.main.models import Device, Experiment |
|
4 | from apps.main.models import Device, Experiment | |
5 | from .models import JARSConfiguration, JARSfilter |
|
5 | from .models import JARSConfiguration, JARSfilter | |
6 | from .widgets import SpectralWidget |
|
6 | from .widgets import SpectralWidget | |
7 | from apps.main.forms import add_empty_choice |
|
7 | from apps.main.forms import add_empty_choice | |
8 |
|
8 | |||
9 | def create_choices_from_model(model, filter_id=None): |
|
9 | def create_choices_from_model(model, filter_id=None): | |
10 |
|
10 | |||
11 | #instance = globals()[model] |
|
11 | #instance = globals()[model] | |
12 | choices = model.objects.all().values_list('pk', 'name') |
|
12 | choices = model.objects.all().values_list('pk', 'name') | |
13 | choices = add_empty_choice(choices) |
|
13 | choices = add_empty_choice(choices) | |
14 | return choices |
|
14 | return choices | |
15 |
|
15 | |||
16 | class JARSConfigurationForm(forms.ModelForm): |
|
16 | class JARSConfigurationForm(forms.ModelForm): | |
17 | def __init__(self, *args, **kwargs): |
|
17 | def __init__(self, *args, **kwargs): | |
18 | super(JARSConfigurationForm, self).__init__(*args, **kwargs) |
|
18 | super(JARSConfigurationForm, self).__init__(*args, **kwargs) | |
19 | instance = getattr(self, 'instance', None) |
|
19 | instance = getattr(self, 'instance', None) | |
20 |
|
20 | |||
21 | if instance and instance.pk: |
|
21 | if instance and instance.pk: | |
22 | devices = Device.objects.filter(device_type__name='jars') |
|
22 | devices = Device.objects.filter(device_type__name='jars') | |
23 |
|
23 | |||
24 | if instance.experiment: |
|
24 | if instance.experiment: | |
25 | experiments = Experiment.objects.filter(pk=instance.experiment.id) |
|
25 | experiments = Experiment.objects.filter(pk=instance.experiment.id) | |
26 | self.fields['experiment'].widget.choices = [(experiment.id, experiment) for experiment in experiments] |
|
26 | self.fields['experiment'].widget.choices = [(experiment.id, experiment) for experiment in experiments] | |
27 |
|
27 | |||
28 | self.fields['device'].widget.choices = [(device.id, device) for device in devices] |
|
28 | self.fields['device'].widget.choices = [(device.id, device) for device in devices] | |
29 | #self.fields['spectral'].widget = SpectralWidget() |
|
29 | #self.fields['spectral'].widget = SpectralWidget() | |
30 | self.fields['spectral_number'].widget.attrs['readonly'] = True |
|
30 | self.fields['spectral_number'].widget.attrs['readonly'] = True | |
31 | self.fields['spectral'].widget = SpectralWidget() |
|
31 | self.fields['spectral'].widget = SpectralWidget() | |
32 |
|
32 | |||
33 | #-------------JARS Configuration needs an Experiment----------------- |
|
33 | #-------------JARS Configuration needs an Experiment----------------- | |
34 | def clean(self): |
|
34 | def clean(self): | |
35 | cleaned_data = super(JARSConfigurationForm, self).clean() |
|
35 | cleaned_data = super(JARSConfigurationForm, self).clean() | |
36 | experiment = cleaned_data.get('experiment') |
|
36 | experiment = cleaned_data.get('experiment') | |
37 | if not experiment: |
|
37 | if not experiment: | |
38 | msg = "Error: Jars Configuration needs an Experiment" |
|
38 | msg = "Error: Jars Configuration needs an Experiment" | |
39 | self.add_error('experiment', msg) |
|
39 | self.add_error('experiment', msg) | |
40 |
|
40 | |||
41 | class Meta: |
|
41 | class Meta: | |
42 | model = JARSConfiguration |
|
42 | model = JARSConfiguration | |
43 | exclude = ('type', 'parameters', 'status', 'filter_parms') |
|
43 | exclude = ('type', 'parameters', 'status', 'filter_parms') | |
44 |
|
44 | |||
45 |
|
45 | |||
46 | class JARSfilterForm(forms.ModelForm): |
|
46 | class JARSfilterForm(forms.ModelForm): | |
47 | def __init__(self, *args, **kwargs): |
|
47 | def __init__(self, *args, **kwargs): | |
48 | super(JARSfilterForm, self).__init__(*args, **kwargs) |
|
48 | super(JARSfilterForm, self).__init__(*args, **kwargs) | |
49 | instance = getattr(self, 'instance', None) |
|
49 | instance = getattr(self, 'instance', None) | |
50 |
|
50 | |||
51 | self.fields['fch_decimal'].widget.attrs['readonly'] = True |
|
51 | self.fields['fch_decimal'].widget.attrs['readonly'] = True | |
52 |
|
52 | |||
53 | if 'initial' in kwargs: |
|
53 | if 'initial' in kwargs: | |
54 | if 'filter_id' not in kwargs['initial']: |
|
54 | if 'filter_id' not in kwargs['initial']: | |
55 | self.fields.pop('name') |
|
55 | self.fields.pop('name') | |
56 | else: |
|
56 | else: | |
57 | self.fields['name'] = forms.ChoiceField(choices=create_choices_from_model(JARSfilter)) |
|
57 | self.fields['name'] = forms.ChoiceField(choices=create_choices_from_model(JARSfilter)) | |
58 | filter_id = kwargs['initial']['filter_id'] |
|
58 | filter_id = kwargs['initial']['filter_id'] | |
59 |
|
59 | |||
60 | if filter_id == 0: |
|
60 | if filter_id == 0: | |
61 | for value in self.fields: |
|
61 | for value in self.fields: | |
62 | if value != 'name': |
|
62 | if value != 'name': | |
63 | self.fields.pop(value) |
|
63 | self.fields.pop(value) | |
64 | self.fields['name'].label = "Filter Template Name" |
|
64 | self.fields['name'].label = "Filter Template Name" | |
65 | else: |
|
65 | else: | |
66 | self.fields['name'] = forms.ChoiceField(choices=create_choices_from_model(JARSfilter, kwargs['initial']['filter_id'])) |
|
66 | self.fields['name'] = forms.ChoiceField(choices=create_choices_from_model(JARSfilter, kwargs['initial']['filter_id'])) | |
67 |
jars_filter = JARSfilter.objects.get(pk=kwargs['initial']['filter_id']) |
|
67 | jars_filter = JARSfilter.objects.get(pk=kwargs['initial']['filter_id']) | |
68 | labels = [f.name for f in jars_filter._meta.get_fields()] |
|
68 | labels = [f.name for f in jars_filter._meta.get_fields()] | |
69 |
|
69 | |||
70 | for label in ['id']: |
|
70 | for label in ['id']: | |
71 | labels.remove(label) |
|
71 | labels.remove(label) | |
72 | for label in labels: |
|
72 | for label in labels: | |
73 | self.fields['name'].initial = kwargs['initial']['filter_id'] |
|
73 | self.fields['name'].initial = kwargs['initial']['filter_id'] | |
74 | self.fields[label].initial = getattr(jars_filter,label) |
|
74 | self.fields[label].initial = getattr(jars_filter,label) | |
75 | self.fields['name'].label = "Filter Template Name" |
|
75 | self.fields['name'].label = "Filter Template Name" | |
76 |
|
76 | |||
77 | class Meta: |
|
77 | class Meta: | |
78 | model = JARSfilter |
|
78 | model = JARSfilter | |
79 | exclude = ('type', 'parameters', 'status') |
|
79 | exclude = ('type', 'parameters', 'status') | |
80 |
|
80 | |||
81 |
|
81 | |||
82 | class ExtFileField(forms.FileField): |
|
82 | class ExtFileField(forms.FileField): | |
83 | """ |
|
83 | """ | |
84 | Same as forms.FileField, but you can specify a file extension whitelist. |
|
84 | Same as forms.FileField, but you can specify a file extension whitelist. | |
85 |
|
85 | |||
86 | >>> from django.core.files.uploadedfile import SimpleUploadedFile |
|
86 | >>> from django.core.files.uploadedfile import SimpleUploadedFile | |
87 | >>> |
|
87 | >>> | |
88 | >>> t = ExtFileField(ext_whitelist=(".pdf", ".txt")) |
|
88 | >>> t = ExtFileField(ext_whitelist=(".pdf", ".txt")) | |
89 | >>> |
|
89 | >>> | |
90 | >>> t.clean(SimpleUploadedFile('filename.pdf', 'Some File Content')) |
|
90 | >>> t.clean(SimpleUploadedFile('filename.pdf', 'Some File Content')) | |
91 | >>> t.clean(SimpleUploadedFile('filename.txt', 'Some File Content')) |
|
91 | >>> t.clean(SimpleUploadedFile('filename.txt', 'Some File Content')) | |
92 | >>> |
|
92 | >>> | |
93 | >>> t.clean(SimpleUploadedFile('filename.exe', 'Some File Content')) |
|
93 | >>> t.clean(SimpleUploadedFile('filename.exe', 'Some File Content')) | |
94 | Traceback (most recent call last): |
|
94 | Traceback (most recent call last): | |
95 | ... |
|
95 | ... | |
96 | ValidationError: [u'Not allowed filetype!'] |
|
96 | ValidationError: [u'Not allowed filetype!'] | |
97 | """ |
|
97 | """ | |
98 | def __init__(self, *args, **kwargs): |
|
98 | def __init__(self, *args, **kwargs): | |
99 | extensions = kwargs.pop("extensions") |
|
99 | extensions = kwargs.pop("extensions") | |
100 | self.extensions = [i.lower() for i in extensions] |
|
100 | self.extensions = [i.lower() for i in extensions] | |
101 |
|
101 | |||
102 | super(ExtFileField, self).__init__(*args, **kwargs) |
|
102 | super(ExtFileField, self).__init__(*args, **kwargs) | |
103 |
|
103 | |||
104 | def clean(self, *args, **kwargs): |
|
104 | def clean(self, *args, **kwargs): | |
105 | data = super(ExtFileField, self).clean(*args, **kwargs) |
|
105 | data = super(ExtFileField, self).clean(*args, **kwargs) | |
106 | filename = data.name |
|
106 | filename = data.name | |
107 | ext = os.path.splitext(filename)[1] |
|
107 | ext = os.path.splitext(filename)[1] | |
108 | ext = ext.lower() |
|
108 | ext = ext.lower() | |
109 | if ext not in self.extensions: |
|
109 | if ext not in self.extensions: | |
110 | raise forms.ValidationError('Not allowed file type: %s' % ext) |
|
110 | raise forms.ValidationError('Not allowed file type: %s' % ext) | |
111 |
|
111 | |||
112 |
|
112 | |||
113 | class JARSImportForm(forms.Form): |
|
113 | class JARSImportForm(forms.Form): | |
114 |
|
114 | |||
115 | file_name = ExtFileField(extensions=['.racp','.json']) |
|
115 | file_name = ExtFileField(extensions=['.racp','.json']) |
@@ -1,240 +1,240 | |||||
1 | from django.shortcuts import render_to_response |
|
1 | from django.shortcuts import render_to_response | |
2 | from django.template import RequestContext |
|
2 | from django.template import RequestContext | |
3 | from django.shortcuts import redirect, render, get_object_or_404 |
|
3 | from django.shortcuts import redirect, render, get_object_or_404 | |
4 | from django.contrib import messages |
|
4 | from django.contrib import messages | |
5 | from django.http import HttpResponse |
|
5 | from django.http import HttpResponse | |
6 |
|
6 | |||
7 | from apps.main.models import Device |
|
7 | from apps.main.models import Device | |
8 | from apps.main.views import sidebar |
|
8 | from apps.main.views import sidebar | |
9 |
|
9 | |||
10 | from .models import JARSConfiguration, JARSfilter |
|
10 | from .models import JARSConfiguration, JARSfilter | |
11 | from .forms import JARSConfigurationForm, JARSfilterForm, JARSImportForm |
|
11 | from .forms import JARSConfigurationForm, JARSfilterForm, JARSImportForm | |
12 |
|
12 | |||
13 | import json |
|
13 | import json | |
14 | # Create your views here. |
|
14 | # Create your views here. | |
15 |
|
15 | |||
16 | def jars_conf(request, id_conf): |
|
16 | def jars_conf(request, id_conf): | |
17 |
|
17 | |||
18 | conf = get_object_or_404(JARSConfiguration, pk=id_conf) |
|
18 | conf = get_object_or_404(JARSConfiguration, pk=id_conf) | |
19 |
|
19 | |||
20 | filter_parms = eval(conf.filter_parms) |
|
20 | filter_parms = eval(conf.filter_parms) | |
21 | if filter_parms.__class__.__name__=='str': |
|
21 | if filter_parms.__class__.__name__=='str': | |
22 | filter_parms = eval(filter_parms) |
|
22 | filter_parms = eval(filter_parms) | |
23 |
|
23 | |||
24 | kwargs = {} |
|
24 | kwargs = {} | |
25 | kwargs['filter'] = filter_parms |
|
25 | kwargs['filter'] = filter_parms | |
26 | kwargs['filter_keys'] = ['clock', 'mult', 'fch', 'fch_decimal', |
|
26 | kwargs['filter_keys'] = ['clock', 'mult', 'fch', 'fch_decimal', | |
27 | 'filter_fir', 'filter_2', 'filter_5'] |
|
27 | 'filter_fir', 'filter_2', 'filter_5'] | |
28 |
|
28 | |||
29 | filter_resolution=conf.filter_resolution() |
|
29 | filter_resolution=conf.filter_resolution() | |
30 | kwargs['resolution'] = '{} (MHz)'.format(filter_resolution) |
|
30 | kwargs['resolution'] = '{} (MHz)'.format(filter_resolution) | |
31 | if filter_resolution < 1: |
|
31 | if filter_resolution < 1: | |
32 | kwargs['resolution'] = '{} (kHz)'.format(filter_resolution*1000) |
|
32 | kwargs['resolution'] = '{} (kHz)'.format(filter_resolution*1000) | |
33 |
|
33 | |||
34 | kwargs['status'] = conf.device.get_status_display() |
|
34 | kwargs['status'] = conf.device.get_status_display() | |
35 |
|
35 | |||
36 |
|
36 | |||
37 | kwargs['dev_conf'] = conf |
|
37 | kwargs['dev_conf'] = conf | |
38 | kwargs['dev_conf_keys'] = ['name', |
|
38 | kwargs['dev_conf_keys'] = ['name', | |
39 | 'cards_number', 'channels_number', 'channels', |
|
39 | 'cards_number', 'channels_number', 'channels', | |
40 |
'ftp_interval', 'data_type','acq_profiles', |
|
40 | 'ftp_interval', 'data_type','acq_profiles', | |
41 | 'profiles_block', 'raw_data_blocks', 'ftp_interval', |
|
41 | 'profiles_block', 'raw_data_blocks', 'ftp_interval', | |
42 | 'cohe_integr_str', 'cohe_integr', 'decode_data', 'post_coh_int', |
|
42 | 'cohe_integr_str', 'cohe_integr', 'decode_data', 'post_coh_int', | |
43 | 'incohe_integr', 'fftpoints', 'spectral_number', |
|
43 | 'incohe_integr', 'fftpoints', 'spectral_number', | |
44 | 'spectral', 'create_directory', 'include_expname', |
|
44 | 'spectral', 'create_directory', 'include_expname', | |
45 | 'save_ch_dc', 'save_data'] |
|
45 | 'save_ch_dc', 'save_data'] | |
46 |
|
46 | |||
47 | if conf.exp_type == 0: |
|
47 | if conf.exp_type == 0: | |
48 | for field in ['incohe_integr','fftpoints','spectral_number', 'spectral', 'save_ch_dc']: |
|
48 | for field in ['incohe_integr','fftpoints','spectral_number', 'spectral', 'save_ch_dc']: | |
49 | kwargs['dev_conf_keys'].remove(field) |
|
49 | kwargs['dev_conf_keys'].remove(field) | |
50 |
|
50 | |||
51 | if conf.decode_data == 0: |
|
51 | if conf.decode_data == 0: | |
52 | kwargs['dev_conf_keys'].remove('decode_data') |
|
52 | kwargs['dev_conf_keys'].remove('decode_data') | |
53 | kwargs['dev_conf_keys'].remove('post_coh_int') |
|
53 | kwargs['dev_conf_keys'].remove('post_coh_int') | |
54 |
|
54 | |||
55 | kwargs['title'] = 'JARS Configuration' |
|
55 | kwargs['title'] = 'JARS Configuration' | |
56 | kwargs['suptitle'] = 'Details' |
|
56 | kwargs['suptitle'] = 'Details' | |
57 |
|
57 | |||
58 | kwargs['button'] = 'Edit Configuration' |
|
58 | kwargs['button'] = 'Edit Configuration' | |
59 |
|
59 | |||
60 | #kwargs['no_play'] = True |
|
60 | #kwargs['no_play'] = True | |
61 |
|
61 | |||
62 | #kwargs['only_stop'] = True |
|
62 | #kwargs['only_stop'] = True | |
63 |
|
63 | |||
64 | ###### SIDEBAR ###### |
|
64 | ###### SIDEBAR ###### | |
65 | kwargs.update(sidebar(conf=conf)) |
|
65 | kwargs.update(sidebar(conf=conf)) | |
66 |
|
66 | |||
67 | return render(request, 'jars_conf.html', kwargs) |
|
67 | return render(request, 'jars_conf.html', kwargs) | |
68 |
|
68 | |||
69 | def jars_conf_edit(request, id_conf): |
|
69 | def jars_conf_edit(request, id_conf): | |
70 |
|
70 | |||
71 | conf = get_object_or_404(JARSConfiguration, pk=id_conf) |
|
71 | conf = get_object_or_404(JARSConfiguration, pk=id_conf) | |
72 |
|
72 | |||
73 | filter_parms = eval(conf.filter_parms) |
|
73 | filter_parms = eval(conf.filter_parms) | |
74 | if filter_parms.__class__.__name__=='str': |
|
74 | if filter_parms.__class__.__name__=='str': | |
75 | filter_parms = eval(filter_parms) |
|
75 | filter_parms = eval(filter_parms) | |
76 |
|
76 | |||
77 | if request.method=='GET': |
|
77 | if request.method=='GET': | |
78 | form = JARSConfigurationForm(instance=conf) |
|
78 | form = JARSConfigurationForm(instance=conf) | |
79 | filter_form = JARSfilterForm(initial=filter_parms) |
|
79 | filter_form = JARSfilterForm(initial=filter_parms) | |
80 |
|
80 | |||
81 | if request.method=='POST': |
|
81 | if request.method=='POST': | |
82 | form = JARSConfigurationForm(request.POST, instance=conf) |
|
82 | form = JARSConfigurationForm(request.POST, instance=conf) | |
83 | filter_form = JARSfilterForm(request.POST) |
|
83 | filter_form = JARSfilterForm(request.POST) | |
84 |
|
84 | |||
85 | if filter_form.is_valid(): |
|
85 | if filter_form.is_valid(): | |
86 | jars_filter = filter_form.cleaned_data |
|
86 | jars_filter = filter_form.cleaned_data | |
87 | try: |
|
87 | try: | |
88 | jars_filter.pop('name') |
|
88 | jars_filter.pop('name') | |
89 | except: |
|
89 | except: | |
90 | pass |
|
90 | pass | |
91 |
|
91 | |||
92 | if form.is_valid(): |
|
92 | if form.is_valid(): | |
93 | conf = form.save(commit=False) |
|
93 | conf = form.save(commit=False) | |
94 | conf.filter_parms = json.dumps(jars_filter) |
|
94 | conf.filter_parms = json.dumps(jars_filter) | |
95 | conf.save() |
|
95 | conf.save() | |
96 | return redirect('url_jars_conf', id_conf=conf.id) |
|
96 | return redirect('url_jars_conf', id_conf=conf.id) | |
97 |
|
97 | |||
98 | kwargs = {} |
|
98 | kwargs = {} | |
99 |
|
99 | |||
100 | kwargs['id_dev'] = conf.id |
|
100 | kwargs['id_dev'] = conf.id | |
101 | kwargs['form'] = form |
|
101 | kwargs['form'] = form | |
102 | kwargs['filter_form'] = filter_form |
|
102 | kwargs['filter_form'] = filter_form | |
103 | kwargs['title'] = 'Device Configuration' |
|
103 | kwargs['title'] = 'Device Configuration' | |
104 | kwargs['suptitle'] = 'Edit' |
|
104 | kwargs['suptitle'] = 'Edit' | |
105 | kwargs['button'] = 'Save' |
|
105 | kwargs['button'] = 'Save' | |
106 |
|
106 | |||
107 | return render(request, 'jars_conf_edit.html', kwargs) |
|
107 | return render(request, 'jars_conf_edit.html', kwargs) | |
108 |
|
108 | |||
109 | def import_file(request, conf_id): |
|
109 | def import_file(request, conf_id): | |
110 |
|
110 | |||
111 | conf = get_object_or_404(JARSConfiguration, pk=conf_id) |
|
111 | conf = get_object_or_404(JARSConfiguration, pk=conf_id) | |
112 | if request.method=='POST': |
|
112 | if request.method=='POST': | |
113 | form = JARSImportForm(request.POST, request.FILES) |
|
113 | form = JARSImportForm(request.POST, request.FILES) | |
114 | if form.is_valid(): |
|
114 | if form.is_valid(): | |
115 | try: |
|
115 | try: | |
116 | data = conf.import_from_file(request.FILES['file_name']) |
|
116 | data = conf.import_from_file(request.FILES['file_name']) | |
117 | conf.dict_to_parms(data) |
|
117 | conf.dict_to_parms(data) | |
118 | messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name']) |
|
118 | messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name']) | |
119 | return redirect(conf.get_absolute_url_edit()) |
|
119 | return redirect(conf.get_absolute_url_edit()) | |
120 |
|
120 | |||
121 | except Exception as e: |
|
121 | except Exception as e: | |
122 | messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], repr(e))) |
|
122 | messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], repr(e))) | |
123 | else: |
|
123 | else: | |
124 | messages.warning(request, 'Your current configuration will be replaced') |
|
124 | messages.warning(request, 'Your current configuration will be replaced') | |
125 | form = JARSImportForm() |
|
125 | form = JARSImportForm() | |
126 |
|
126 | |||
127 | kwargs = {} |
|
127 | kwargs = {} | |
128 | kwargs['form'] = form |
|
128 | kwargs['form'] = form | |
129 | kwargs['title'] = 'JARS Configuration' |
|
129 | kwargs['title'] = 'JARS Configuration' | |
130 | kwargs['suptitle'] = 'Import file' |
|
130 | kwargs['suptitle'] = 'Import file' | |
131 | kwargs['button'] = 'Upload' |
|
131 | kwargs['button'] = 'Upload' | |
132 | kwargs['previous'] = conf.get_absolute_url() |
|
132 | kwargs['previous'] = conf.get_absolute_url() | |
133 |
|
133 | |||
134 | return render(request, 'jars_import.html', kwargs) |
|
134 | return render(request, 'jars_import.html', kwargs) | |
135 |
|
135 | |||
136 | def read_conf(request, conf_id): |
|
136 | def read_conf(request, conf_id): | |
137 |
|
137 | |||
138 | conf = get_object_or_404(JARSConfiguration, pk=conf_id) |
|
138 | conf = get_object_or_404(JARSConfiguration, pk=conf_id) | |
139 | #filter = get_object_or_404(JARSfilter, pk=filter_id) |
|
139 | #filter = get_object_or_404(JARSfilter, pk=filter_id) | |
140 |
|
140 | |||
141 | if request.method=='GET': |
|
141 | if request.method=='GET': | |
142 |
|
142 | |||
143 | parms = conf.read_device() |
|
143 | parms = conf.read_device() | |
144 | conf.status_device() |
|
144 | conf.status_device() | |
145 |
|
145 | |||
146 | if not parms: |
|
146 | if not parms: | |
147 | messages.error(request, conf.message) |
|
147 | messages.error(request, conf.message) | |
148 | return redirect(conf.get_absolute_url()) |
|
148 | return redirect(conf.get_absolute_url()) | |
149 |
|
149 | |||
150 | form = JARSConfigurationForm(initial=parms, instance=conf) |
|
150 | form = JARSConfigurationForm(initial=parms, instance=conf) | |
151 |
|
151 | |||
152 | if request.method=='POST': |
|
152 | if request.method=='POST': | |
153 | form = JARSConfigurationForm(request.POST, instance=conf) |
|
153 | form = JARSConfigurationForm(request.POST, instance=conf) | |
154 |
|
154 | |||
155 | if form.is_valid(): |
|
155 | if form.is_valid(): | |
156 | form.save() |
|
156 | form.save() | |
157 | return redirect(conf.get_absolute_url()) |
|
157 | return redirect(conf.get_absolute_url()) | |
158 |
|
158 | |||
159 | messages.error(request, "Parameters could not be saved") |
|
159 | messages.error(request, "Parameters could not be saved") | |
160 |
|
160 | |||
161 | kwargs = {} |
|
161 | kwargs = {} | |
162 | kwargs['id_dev'] = conf.id |
|
162 | kwargs['id_dev'] = conf.id | |
163 | kwargs['filter_id'] = conf.filter.id |
|
163 | kwargs['filter_id'] = conf.filter.id | |
164 | kwargs['form'] = form |
|
164 | kwargs['form'] = form | |
165 | kwargs['title'] = 'Device Configuration' |
|
165 | kwargs['title'] = 'Device Configuration' | |
166 | kwargs['suptitle'] = 'Parameters read from device' |
|
166 | kwargs['suptitle'] = 'Parameters read from device' | |
167 | kwargs['button'] = 'Save' |
|
167 | kwargs['button'] = 'Save' | |
168 |
|
168 | |||
169 | ###### SIDEBAR ###### |
|
169 | ###### SIDEBAR ###### | |
170 | kwargs.update(sidebar(conf=conf)) |
|
170 | kwargs.update(sidebar(conf=conf)) | |
171 |
|
171 | |||
172 | return render(request, 'jars_conf_edit.html', kwargs) |
|
172 | return render(request, 'jars_conf_edit.html', kwargs) | |
173 |
|
173 | |||
174 |
|
174 | |||
175 |
|
175 | |||
176 | def change_filter(request, conf_id, filter_id=None): |
|
176 | def change_filter(request, conf_id, filter_id=None): | |
177 |
|
177 | |||
178 | conf = get_object_or_404(JARSConfiguration, pk=conf_id) |
|
178 | conf = get_object_or_404(JARSConfiguration, pk=conf_id) | |
179 |
|
179 | |||
180 | if filter_id: |
|
180 | if filter_id: | |
181 | if filter_id.__class__.__name__ not in ['int', 'float']: |
|
181 | if filter_id.__class__.__name__ not in ['int', 'float']: | |
182 | filter_id = eval(filter_id) |
|
182 | filter_id = eval(filter_id) | |
183 |
|
183 | |||
184 | if filter_id == 0: |
|
184 | if filter_id == 0: | |
185 | return redirect('url_change_jars_filter', conf_id=conf.id) |
|
185 | return redirect('url_change_jars_filter', conf_id=conf.id) | |
186 |
|
186 | |||
187 | if request.method=='GET': |
|
187 | if request.method=='GET': | |
188 | if not filter_id: |
|
188 | if not filter_id: | |
189 | form = JARSfilterForm(initial={'filter_id': 0}) |
|
189 | form = JARSfilterForm(initial={'filter_id': 0}) | |
190 | else: |
|
190 | else: | |
191 | form = JARSfilterForm(initial={'filter_id': filter_id}) |
|
191 | form = JARSfilterForm(initial={'filter_id': filter_id}) | |
192 |
|
192 | |||
193 | if request.method=='POST': |
|
193 | if request.method=='POST': | |
194 | form = JARSfilterForm(request.POST) |
|
194 | form = JARSfilterForm(request.POST) | |
195 | if form.is_valid(): |
|
195 | if form.is_valid(): | |
196 | jars_filter = form.cleaned_data |
|
196 | jars_filter = form.cleaned_data | |
197 | try: |
|
197 | try: | |
198 | jars_filter.pop('name') |
|
198 | jars_filter.pop('name') | |
199 | except: |
|
199 | except: | |
200 | pass |
|
200 | pass | |
201 | conf.filter_parms = json.dumps(jars_filter) |
|
201 | conf.filter_parms = json.dumps(jars_filter) | |
202 | conf.save() |
|
202 | conf.save() | |
203 | return redirect('url_edit_jars_conf', id_conf=conf.id) |
|
203 | return redirect('url_edit_jars_conf', id_conf=conf.id) | |
204 | else: |
|
204 | else: | |
205 | messages.error(request, "Select a Filter Template") |
|
205 | messages.error(request, "Select a Filter Template") | |
206 | return redirect('url_change_jars_filter', conf_id=conf.id) |
|
206 | return redirect('url_change_jars_filter', conf_id=conf.id) | |
207 |
|
207 | |||
208 | kwargs = {} |
|
208 | kwargs = {} | |
209 | kwargs['title'] = 'JARS Configuration' |
|
209 | kwargs['title'] = 'JARS Configuration' | |
210 | kwargs['suptitle'] = 'Change Filter' |
|
210 | kwargs['suptitle'] = 'Change Filter' | |
211 | kwargs['form'] = form |
|
211 | kwargs['form'] = form | |
212 | kwargs['button'] = 'Change' |
|
212 | kwargs['button'] = 'Change' | |
213 | kwargs['conf_id'] = conf.id |
|
213 | kwargs['conf_id'] = conf.id | |
214 | kwargs['filter_id'] = filter_id |
|
214 | kwargs['filter_id'] = filter_id | |
215 | return render(request, 'change_jars_filter.html', kwargs) |
|
215 | return render(request, 'change_jars_filter.html', kwargs) | |
216 |
|
216 | |||
217 |
|
217 | |||
218 | def get_log(request, conf_id): |
|
218 | def get_log(request, conf_id): | |
219 |
|
219 | |||
220 | conf = get_object_or_404(JARSConfiguration, pk=conf_id) |
|
220 | conf = get_object_or_404(JARSConfiguration, pk=conf_id) | |
221 | response = conf.get_log() |
|
221 | response = conf.get_log() | |
222 |
|
222 | |||
223 | if not response: |
|
223 | if not response: | |
224 | message = conf.message |
|
224 | message = conf.message | |
225 | messages.error(request, message) |
|
225 | messages.error(request, message) | |
226 | return redirect('url_jars_conf', id_conf=conf.id) |
|
226 | return redirect('url_jars_conf', id_conf=conf.id) | |
227 |
|
227 | |||
228 | try: |
|
228 | try: | |
229 | message = response.json()['message'] |
|
229 | message = response.json()['message'] | |
230 | messages.error(request, message) |
|
230 | messages.error(request, message) | |
231 | return redirect('url_jars_conf', id_conf=conf.id) |
|
231 | return redirect('url_jars_conf', id_conf=conf.id) | |
232 | except Exception as e: |
|
232 | except Exception as e: | |
233 | message = 'Restarting Report.txt has been downloaded successfully.' |
|
233 | message = 'Restarting Report.txt has been downloaded successfully.' | |
234 |
|
234 | |||
235 | content = response |
|
235 | content = response | |
236 | filename = 'Log_%s_%s.txt' %(conf.experiment.name, conf.experiment.id) |
|
236 | filename = 'Log_%s_%s.txt' %(conf.experiment.name, conf.experiment.id) | |
237 | response = HttpResponse(content,content_type='text/plain') |
|
237 | response = HttpResponse(content,content_type='text/plain') | |
238 | response['Content-Disposition'] = 'attachment; filename="%s"' %filename |
|
238 | response['Content-Disposition'] = 'attachment; filename="%s"' %filename | |
239 |
|
239 | |||
240 | return response No newline at end of file |
|
240 | return response |
General Comments 0
You need to be logged in to leave comments.
Login now