radarsys Commit - r269:739a60f98369 · Jicamarca Repository

Filter template name combo box and change_filter views...

Fiorella Quino -

r269:739a60f98369

parent child

Context file:

r269:739a60f98369

Collapse all files

apps/jars/templates/change_jars_filter.html created 644 +13 0

@@ -0,0 +1,13
	1	{% extends "dev_conf_edit.html" %}
	2
	3	{% block extra-js%}
	4
	5	<script type="text/javascript">
	6
	7	$("#id_name").change(function() {
	8	var url = "{% url 'url_change_jars_filter' conf_id %}";
	9	document.location = url + $(this).val()+"/";
	10	});
	11
	12	</script>
	13	{% endblock %}

apps/jars/fixtures/initial_filters_data.json +3 -2

@@ -1,2 +1,3
1	[{"fields": {"name": "49_920MHz_clock60MHz_F0MHz_12_25_2", "clock": "60", "mult": 5, "fch": 49.92, "fch_decimal": ~~721554505~~, "filter_fir": 6, "filter_2": 10, "filter_5": 1, ~~"speed"~~: 0}, "model": "jars.jarsfilter", "pk": 1}	1	[{"fields": {"name": "49_92MHz_clock60MHz_F1KHz_12_25_2", "clock": 60, "mult": 5, "fch": 49.92, "fch_decimal": 721554506, "filter_fir": 2, "filter_2": 12, "filter_5": 25}, "model": "jars.jarsfilter", "pk": 1}
2	]	2	{"fields": {"name": "49_920MHz_clock60MHz_F1MHz_10_1_6", "clock": 60, "mult": 5, "fch": 49.92, "fch_decimal": 721554506, "filter_fir": 6, "filter_2": 10, "filter_5": 1}, "model": "jars.jarsfilter", "pk": 2}
		3	]

apps/jars/forms.py +32 -4

             import os
             from django import forms
             from apps.main.models import Device, Experiment
             from .models import JARSConfiguration, JARSfilter
             from .widgets import SpectralWidget
+            from apps.main.forms import add_empty_choice
+            def create_choices_from_model(model, filter_id=None):
+                #instance = globals()[model]
+                choices = model.objects.all().values_list('pk', 'name')
+                choices = add_empty_choice(choices)
+                return choices
             class JARSConfigurationForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(JARSConfigurationForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     if instance and instance.pk:
                         devices = Device.objects.filter(device_type__name='jars')
                         if instance.experiment:
                             experiments = Experiment.objects.filter(pk=instance.experiment.id)
                             self.fields['experiment'].widget.choices = [(experiment.id, experiment) for experiment in experiments]
                         self.fields['device'].widget.choices = [(device.id, device) for device in devices]
                         #self.fields['spectral'].widget = SpectralWidget()
                     self.fields['spectral_number'].widget.attrs['readonly'] = True
                     self.fields['spectral'].widget = SpectralWidget()
                 #-------------JARS Configuration needs an Experiment-----------------
                 def clean(self):
                     cleaned_data = super(JARSConfigurationForm, self).clean()
                     experiment = cleaned_data.get('experiment')
                     if experiment == None:
                         msg = "Error: Jars Configuration needs an Experiment"
                         self.add_error('experiment', msg)
                 class Meta:
                     model = JARSConfiguration
                     exclude = ('type', 'parameters', 'status', 'filter_parms')
             class JARSfilterForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(JARSfilterForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     self.fields['fch_decimal'].widget.attrs['readonly'] = True
                     if 'initial' in kwargs:
-                        self.fields.pop('name')
+                        if 'filter_id' not in kwargs['initial']:
-                        #self.fields['name'].widget.attrs['disabled'] = 'disabled'
+                            self.fields.pop('name')
+                        else:
+                            self.fields['name'] = forms.ChoiceField(choices=create_choices_from_model(JARSfilter))
+                            filter_id = kwargs['initial']['filter_id']
+                            if filter_id == 0:
+                                for value in self.fields:
+                                    if value != 'name':
+                                        self.fields.pop(value)
+                                self.fields['name'].label = "Filter Template Name"
+                            else:
+                                self.fields['name'] = forms.ChoiceField(choices=create_choices_from_model(JARSfilter, kwargs['initial']['filter_id']))
+                                jars_filter = JARSfilter.objects.get(pk=kwargs['initial']['filter_id'])
+                                labels = [f.name for f in jars_filter._meta.get_fields()]
+                                for label in ['id', 'jarsconfiguration']:
+                                    labels.remove(label)
+                                for label in labels:
+                                    self.fields['name'].initial = kwargs['initial']['filter_id']
+                                    self.fields[label].initial = getattr(jars_filter,label)
+                                self.fields['name'].label = "Filter Template Name"
                 class Meta:
                     model = JARSfilter
                     exclude = ('type', 'parameters', 'status')
             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:
                         raise forms.ValidationError('Not allowed file type: %s' % ext)
             class JARSImportForm(forms.Form):
                 #file_name = ExtFileField(extensions=['.racp', '.json', '.dat'])
                 file_name = ExtFileField(extensions=['.json'])

apps/jars/models.py +15 -9

             import json
             import requests
             from django.db import models
             from django.core.validators import MinValueValidator, MaxValueValidator
             from django.core.urlresolvers import reverse
             from apps.main.models import Configuration
             from apps.main.utils import Params
             # Create your models here.
             EXPERIMENT_TYPE = (
                                (0, 'RAW_DATA'),
                                (1, 'PDATA'),
                                )
             DATA_TYPE = (
                          (0, 'SHORT'),
                          (1, 'FLOAT'),
                          )
             DECODE_TYPE = (
                          (0, 'None'),
                          (1, 'TimeDomain'),
                          (2, 'FreqDomain'),
                          (3, 'InvFreqDomain'),
                          )
             class JARSfilter(models.Model):
                 JARS_NBITS = 32
                 name        = models.CharField(max_length=60, unique=True, default='')
                 clock       = models.FloatField(verbose_name='Clock In (MHz)',validators=[MinValueValidator(5), MaxValueValidator(75)], null=True, default=60)
                 mult        = models.PositiveIntegerField(verbose_name='Multiplier',validators=[MinValueValidator(1), MaxValueValidator(20)], default=5)
-                fch         = models.DecimalField(verbose_name='Frequency (MHz)', validators=[MaxValueValidator(150)], max_digits=19, decimal_places=16, null=True, default=49.9200)
+                fch         = models.FloatField(verbose_name='Frequency (MHz)', validators=[MaxValueValidator(150)], null=True, default=49.9200)
                 fch_decimal = models.BigIntegerField(verbose_name='Frequency (Decimal)',validators=[MinValueValidator(-9223372036854775808), MaxValueValidator(2**JARS_NBITS-1)], null=True, default=721554505)
                 filter_2    = models.PositiveIntegerField(verbose_name='Filter 2',validators=[MinValueValidator(2), MaxValueValidator(100)], default = 10)
                 filter_5    = models.PositiveIntegerField(verbose_name='Filter 5',validators=[MinValueValidator(1), MaxValueValidator(100)], default = 1)
                 filter_fir  = models.PositiveIntegerField(verbose_name='FIR Filter',validators=[MinValueValidator(1), MaxValueValidator(100)], default = 6)
-                #speed       = models.PositiveIntegerField(verbose_name='Speed',validators=[MinValueValidator(0), MaxValueValidator(100000)], default = 0)
                 class Meta:
                     db_table = 'jars_filters'
                 def __unicode__(self):
                     return u'%s' % (self.name)
                 def parms_to_dict(self):
                     parameters = {}
                     #parameters['name']        = self.name
                     parameters['clock']       = float(self.clock)
                     parameters['mult']        = int(self.mult)
                     parameters['fch']         = float(self.fch)
                     parameters['fch_decimal'] = int(self.fch)
                     parameters['filter_fir']  = int(self.filter_fir)
                     parameters['filter_2']    = int(self.filter_2)
                     parameters['filter_5']    = int(self.filter_5)
-                    #parameters['speed']       = int(self.speed)
                     return parameters
                 def dict_to_parms(self, parameters):
                     #self.name        = parameters['name']
                     self.clock       = parameters['clock']
                     self.mult        = parameters['mult']
                     self.fch         = parameters['fch']
                     self.fch_decimal = parameters['fch_decimal']
                     self.filter_fir  = parameters['filter_fir']
                     self.filter_2    = parameters['filter_2']
                     self.filter_5    = parameters['filter_5']
-                    #self.speed       = parameters['speed']
             class JARSConfiguration(Configuration):
                 ADC_RESOLUTION   = 8
                 PCI_DIO_BUSWIDTH = 32
                 HEADER_VERSION   = 1103
                 BEGIN_ON_START   = True
                 REFRESH_RATE     = 1
-                #rc               = models.ForeignKey(RCConfiguration, on_delete=models.CASCADE, null=True)
                 exp_type         = models.PositiveIntegerField(verbose_name='Experiment Type', choices=EXPERIMENT_TYPE, default=0)
                 cards_number     = models.PositiveIntegerField(verbose_name='Number of Cards', validators=[MinValueValidator(1), MaxValueValidator(4)], default = 1)
                 channels_number  = models.PositiveIntegerField(verbose_name='Number of Channels', validators=[MinValueValidator(1), MaxValueValidator(8)], default = 5)
                 channels         = models.CharField(verbose_name='Channels', max_length=15, default = '1,2,3,4,5')
-                #rd_directory     = models.CharField(verbose_name='Raw Data Directory', max_length=200, default='', blank=True, null=True)
-                #pd_directory     = models.CharField(verbose_name='Process Data Directory', max_length=200, default='', blank=True, null=True)
                 data_type        = models.PositiveIntegerField(verbose_name='Data Type', choices=DATA_TYPE, default=0)
                 raw_data_blocks  = models.PositiveIntegerField(verbose_name='Raw Data Blocks', validators=[MaxValueValidator(5000)], default=60)
                 profiles_block   = models.PositiveIntegerField(verbose_name='Profiles Per Block', default=400)
                 acq_profiles     = models.PositiveIntegerField(verbose_name='Acquired Profiles', default=400)
                 ftp_interval     = models.PositiveIntegerField(verbose_name='FTP Interval', default=60)
                 fftpoints        = models.PositiveIntegerField(verbose_name='FFT Points',default=16)
                 cohe_integr_str  = models.PositiveIntegerField(verbose_name='Coh. Int. Stride',validators=[MinValueValidator(1)], default=30)
                 cohe_integr      = models.PositiveIntegerField(verbose_name='Coherent Integrations',validators=[MinValueValidator(1)], default=30)
                 incohe_integr    = models.PositiveIntegerField(verbose_name='Incoherent Integrations',validators=[MinValueValidator(1)], default=30)
                 decode_data      = models.PositiveIntegerField(verbose_name='Decode Data', choices=DECODE_TYPE, default=0)
                 post_coh_int     = models.BooleanField(verbose_name='Post Coherent Integration', default=False)
                 filter           = models.ForeignKey(JARSfilter, on_delete=models.CASCADE, null=True)
                 spectral_number  = models.PositiveIntegerField(verbose_name='# Spectral Combinations',validators=[MinValueValidator(1)], default=1)
                 spectral         = models.CharField(verbose_name='Combinations', max_length=5000, default = '[0, 0],')
                 create_directory = models.BooleanField(verbose_name='Create Directory Per Day', default=True)
                 include_expname  = models.BooleanField(verbose_name='Experiment Name in Directory', default=False)
-                #acq_link         = models.BooleanField(verbose_name='Acquisition Link', default=True)
                 #view_raw_data    = models.BooleanField(verbose_name='View Raw Data', default=True)
                 save_ch_dc       = models.BooleanField(verbose_name='Save Channels DC', default=True)
                 save_data        = models.BooleanField(verbose_name='Save Data', default=True)
-                filter_parms     = models.CharField(max_length=10000, default='{}')
+                filter_parms     = models.CharField(max_length=10000, default='{"name": "49_92MHz_clock60MHz_F1KHz_12_25_2", "clock": 60, "mult": 5, "fch": 49.92, "fch_decimal":	721554506, "filter_fir": 2, "filter_2": 12, "filter_5": 25}, "model": "jars.jarsfilter", "pk": 1}')
                 class Meta:
                     db_table = 'jars_configurations'
                 def add_parms_to_filter(self):
                     self.filter_parms = self.filter.parms_to_dict()
                     self.save()
+                def filter_resolution(self):
+                    filter_parms = eval(self.filter_parms)
+                    if filter_parms.__class__.__name__=='str':
+                        filter_parms = eval(filter_parms)
+                    filter_clock = filter_parms['clock']
+                    filter_2 = filter_parms['filter_2']
+                    filter_5 = filter_parms['filter_5']
+                    filter_fir = filter_parms['filter_fir']
+                    resolution = round((filter_clock/(filter_2*filter_5*filter_fir)),2)
+                    return resolution
                 def dict_to_parms(self, params, id=None):
                     if id is not None:
                         data = Params(params).get_conf(id_conf=id)
                     else:
                         data = Params(params).get_conf(dtype='jars')
                     self.name           = data['name']
                     self.exp_type        = data['exp_type']
                     #if data['exp_type'] in (1, '1') :
                     self.incohe_integr   = data['incohe_integr']
                     self.spectral_number = data['spectral_number']
                     self.spectral        = data['spectral']
                     #self.pd_directory    = data['pd_directory']
                     self.cards_number    = data['cards_number']
                     self.channels_number = data['channels_number']
                     self.channels        = data['channels']
                     #self.rd_directory    = data['rd_directory']
                     #self.raw_data_blocks = data['raw_data_blocks']
                     self.data_type       = data['data_type']
                     self.cohe_integr_str = data['cohe_integr_str']
                     self.acq_profiles    = data['acq_profiles']
                     self.profiles_block  = data['profiles_block']
                     self.ftp_interval    = data['ftp_interval']
                     self.fftpoints       = data['fftpoints']
                     self.cohe_integr     = data['cohe_integr']
                     self.filter_parms = json.dumps(data['filter_parms'])
                     self.create_directory = data['create_directory']
                     self.include_expname  = data['include_expname']
                     #self.acq_link         = data['acq_link']
                     #self.view_raw_data    = data['view_raw_data']
                     self.save_ch_dc       = data['save_ch_dc']
                     self.save_data        = data['save_data']
                     self.save()
                 def request(self, cmd, method='get', **kwargs):
                     req = getattr(requests, method)(self.device.url(cmd), **kwargs)
                     payload = req.json()
                     return payload
                 def status_device(self):
                     try:
                         payload = self.request('status',
                                                params={'name': self.experiment.name})
                         self.device.status = payload['status']
                         self.device.save()
                         self.message = payload['message']
                     except Exception as e:
                         self.device.status = 0
                         self.message = str(e)
                         self.device.save()
                         return False
                     return True
                 def stop_device(self):
                     try:
                         payload = self.request('stop', 'post')
                         self.device.status = payload['status']
                         self.device.save()
                         self.message = payload['message']
                     except Exception as e:
                         self.device.status = 0
                         self.message = str(e)
                         self.device.save()
                         return False
                     return True
                 def read_device(self):
                     try:
                         payload = self.request('read', params={'name': self.experiment.name})
                         self.message = 'Configuration loaded'
                     except:
                         self.device.status = 0
                         self.device.save()
                         self.message = 'Could not read JARS configuration.'
                         return False
                     return payload
                 def write_device(self):
                     if self.device.status == 3:
                         self.message = 'Could not configure device. Software Acquisition is running'
                         return False
                     data = self.experiment.parms_to_dict()
                     for key in data['configurations']['allIds']:
                         if data['configurations']['byId'][key]['device_type'] in ('dds', 'cgs'):
                             data['configurations']['allIds'].remove(key)
                             data['configurations']['byId'].pop(key)
                         elif data['configurations']['byId'][key]['device_type'] == 'jars':
                             data['configurations']['byId'][key] = self.parms_to_dict()['configurations']['byId'][str(self.pk)]
                         elif data['configurations']['byId'][key]['device_type'] == 'rc':
                                 data['configurations']['byId'][key]['pulses'] = ''
                                 data['configurations']['byId'][key]['delays'] = ''
                     rc_ids = [pk for pk in data['configurations']['allIds'] if data['configurations']['byId'][pk]['device_type']=='rc']
                     mix_ids = [pk for pk in rc_ids if data['configurations']['byId'][pk]['mix']]
                     if mix_ids:
                         params = data['configurations']['byId'][mix_ids[0]]['parameters']
                         rc = data['configurations']['byId'][params.split('-')[0].split('|')[0]]
                         rc['mix'] = True
                         data['configurations']['byId'][rc['id']] = rc
                     elif len(rc_ids)==0:
                         self.message = 'Missing RC configuration'
                         return False
                     json_data = json.dumps(data)
                     print json_data
                     try:
                         payload = self.request('write', 'post', json=json_data)
                         self.device.status = payload['status']
                         self.message = payload['message']
                         self.device.save()
                         if self.device.status == 1:
                             return False
                     except Exception as e:
                         self.device.status = 0
                         self.message = str(e)
                         self.device.save()
                         return False
                     return True
                 def start_device(self):
                     try:
                         payload = self.request('start', 'post',
                                                json={'name': self.experiment.name})
                         self.device.status = payload['status']
                         self.message = payload['message']
                         self.device.save()
                         if self.device.status == 1:
                             return False
                     except Exception as e:
                         self.device.status = 0
                         self.message = str(e)
                         self.device.save()
                         return False
                     return True
                 def update_from_file(self, filename):
                     f = JARSFile(filename)
                     self.dict_to_parms(f.data)
                     self.save()
                 def get_absolute_url_import(self):
                     return reverse('url_import_jars_conf', args=[str(self.id)])
                 def get_absolute_url_read(self):
                     return reverse('url_read_jars_conf', args=[str(self.id)])

apps/jars/templates/jars_conf.html +16 -1

@@ -1,1 +1,16
1	{% extends "dev_conf.html" %} No newline at end of file	1	{% extends "dev_conf.html" %}
		2	{% load static %}
		3	{% load bootstrap3 %}
		4	{% load main_tags %}
		5
		6
		7	{% block extra-content %}
		8
		9	<div class="clearfix"></div>
		10	<h2>JARS filter: {{resolution}} (MHz)</h2>
		11	<hr>
		12	<div class="panel-group" id="div_lines" role="tablist" aria-multiselectable="true">
		13	{% include "jars_filter.html" %}
		14	</div>
		15
		16	{% endblock extra-content%}

apps/jars/templates/jars_conf_edit.html +11 -12

             {% extends "dev_conf_edit.html" %}
             {% load bootstrap3 %}
             {% load static %}
             {% load main_tags %}
             {% block content %}
             <form class="form" method="post">
               {% csrf_token %}
               {% bootstrap_form form layout='horizontal' size='medium' %}
               <div style="clear: both;"></div>
-              <br>
+              <h2>JARS filter</h2>
-              <div class="pull-right">
+              <hr>
-              <button type="button" class="btn btn-primary" id="bt_view_filter">View Filter</button>
+              <div class="panel-group" id="div_lines" role="tablist" aria-multiselectable="true">
-              <!-- <button type="button" class="btn btn-primary" onclick="{% if previous %}window.location.replace('{{ previous }}');{% else %}history.go(-1);{% endif %}">Cancel</button>  -->
+              {% include "jars_filter_edit.html" %}
-              <button type="button" class="btn btn-primary" id="bt_cancel">Cancel</button>
-              <button type="submit" class="btn btn-primary">{{button}}</button>
               </div>
+              <div style="clear: both;"></div>
+              <br>
             </form>
             {% endblock %}
             {% block extra-js%}
             <script src="{% static 'js/jars.js' %}"></script>
             <script type="text/javascript">
-            $("#bt_view_filter").click(function() {
-                document.location = "{% url 'url_jars_filter' id_dev filter_id%}";
-              });
             $("#bt_cancel").click(function() {
                 document.location = "{% url 'url_jars_conf' id_dev %}";
-              });
+            });
             </script>
-            {% endblock %}
  No newline at end of file
+            {% endblock %}

apps/jars/templates/jars_filter.html +10 -42

@@ -1,59 +1,27
1	{% extends "base.html" %}
2	{% load bootstrap3 %}	1	{% load bootstrap3 %}
3	{% load static %}	2	{% load static %}
4	{% load main_tags %}	3	{% load main_tags %}
5		4
6	{% block search-active %}active{% endblock %}
7
8	{% block content-title %}{{title}}{% endblock %}
9	{% block content-suptitle %}{{suptitle}}{% endblock %}
10
11	{% block content %}	5	{% block content %}
12		6
13	{% block menu-actions %}	7	{% block menu-actions %}
14		8
15	{% endblock %}	9	{% endblock %}
16		10
17	<table class="table table-bordered">	11	<table class="table table-bordered">
18		12
19	{% for key in dev_conf_keys %}	13	<tr> <th>Clock in (MHz)</th><td>{{filter.clock}}</td> </tr>
20	<tr>	14	<tr> <th>Multiplier</th><td>{{filter.mult}}</td> </tr>
21	<th>{% get_verbose_field_name dev_conf key %}</th>	15	<tr> <th>Frequency (MHz)</th><td>{{filter.fch}}</td> </tr>
22	<td>{{dev_conf\|attr:key}}</td>	16	<tr> <th>Frequency (Decimal)</th><td>{{filter.fch_decimal}}</td> </tr>
23	</tr>	17	<tr> <th>Filter 2</th><td>{{filter.filter_2}}</td> </tr>
24	{% endfor %}	18	<tr> <th>Filter 5</th><td>{{filter.filter_5}}</td> </tr>
		19	<tr> <th>FIR Filter</th><td>{{filter.filter_fir}}</td> </tr>
		20
25	</table>	21	</table>
26	{% if button %}
27	<div class="pull-right">
28	<button type="button" class="btn btn-primary" id="back_button">{% if cancel %}{{cancel}}{% else %}Back{% endif %}</button>
29	<button type="button" id="edit_button" class="btn btn-primary">{{edit_button}}</button>
30	<button type="button" id="new_button" class="btn btn-primary">{{add_button}}</button>
31	</div>
32	{% endif %}
33		22
34	{% block extra-content %}
35	{% endblock %}
36		23
		24	{% block extra-content %}
37	{% endblock %}	25	{% endblock %}
38		26
39	{% block sidebar%}
40	{% include "sidebar_devices.html" %}
41	{% endblock %}	27	{% endblock %}
42
43	{% block extra-js%}
44	<script type="text/javascript">
45
46	$("#edit_button").click(function() {
47	document.location = "{% url 'url_edit_jars_filter' conf.id filter.id%}";
48	});
49
50	$("#back_button").click(function() {
51	document.location = "{% url 'url_edit_jars_conf' conf.id%}";
52	});
53
54	$("#new_button").click(function() {
55	document.location = "{% url 'url_new_jars_filter' conf.id%}";
56	});
57
58	</script>
59	{% endblock %} No newline at end of file

apps/jars/templates/jars_filter_edit.html +13 -5

-            {% extends "dev_conf_edit.html" %}
             {% load bootstrap3 %}
             {% load static %}
             {% load main_tags %}
             {% block content %}
             <form class="form" method="post">
               {% csrf_token %}
-              {% bootstrap_form form layout='horizontal' size='medium' %}
+              {% bootstrap_form filter_form layout='horizontal' size='medium' %}
               <div style="clear: both;"></div>
               <br>
               <div class="pull-right">
-              <button type="button" class="btn btn-primary" onclick="{% if previous %}window.location.replace('{{ previous }}');{% else %}history.go(-1);{% endif %}">Cancel</button>
+                <button type="button" class="btn btn-primary" onclick="{% if previous %}window.location.replace('{{ previous }}');{% else %}history.go(-1);{% endif %}">Cancel</button>
-              <button type="submit" class="btn btn-primary">{{button}}</button>
+                <button type="button" class="btn btn-primary" id="bt_change_filter">Change Filter</button>
+                <button type="submit" class="btn btn-primary">{{button}}</button>
               </div>
             </form>
             {% endblock %}
             {% block extra-js%}
             <script src="{% static 'js/filters.js' %}"></script>
-            {% endblock %}
  No newline at end of file
+            <script type="text/javascript">
+            $("#bt_change_filter").click(function() {
+              document.location = "{% url 'url_change_jars_filter' id_dev %}";
+            });
+            </script>
+            {% endblock %}

apps/jars/urls.py +2 0

             from django.conf.urls import url
             from apps.jars import views
             urlpatterns = (
                 url(r'^(?P<id_conf>-?\d+)/$', views.jars_conf, name='url_jars_conf'),
                 url(r'^(?P<id_conf>-?\d+)/edit/$', views.jars_conf_edit, name='url_edit_jars_conf'),
                 url(r'^(?P<conf_id>-?\d+)/new_filter/$', views.new_filter, name='url_new_jars_filter'),
+                url(r'^(?P<conf_id>-?\d+)/change_filter/$', views.change_filter, name='url_change_jars_filter'),
+                url(r'^(?P<conf_id>-?\d+)/change_filter/(?P<filter_id>-?\d+)/$', views.change_filter, name='url_change_jars_filter'),
                 url(r'^(?P<conf_id>-?\d+)/view_filter/(?P<filter_id>-?\d+)/$', views.view_filter, name='url_jars_filter'),
                 url(r'^(?P<conf_id>-?\d+)/view_filter/(?P<filter_id>-?\d+)/edit$', views.edit_filter, name='url_edit_jars_filter'),
                 url(r'^(?P<conf_id>-?\d+)/import/$', views.import_file, name='url_import_jars_conf'),
                 url(r'^(?P<conf_id>-?\d+)/read/$', views.read_conf, name='url_read_jars_conf'),
             )

apps/jars/views.py +52 -5

             from django.shortcuts import render_to_response
             from django.template import RequestContext
             from django.shortcuts import redirect, render, get_object_or_404
             from django.contrib import messages
             from apps.main.models import Device
             from apps.main.views import sidebar
             from .models import JARSConfiguration, JARSfilter
             from .forms import JARSConfigurationForm, JARSfilterForm, JARSImportForm
+            import json
             # Create your views here.
             def jars_conf(request, id_conf):
                 conf = get_object_or_404(JARSConfiguration, pk=id_conf)
-                ip=conf.device.ip_address
+                filter_parms = eval(conf.filter_parms)
-                port=conf.device.port_address
+                if filter_parms.__class__.__name__=='str':
+                    filter_parms = eval(filter_parms)
                 kwargs = {}
+                kwargs['filter'] = filter_parms
+                kwargs['filter_keys']  = ['clock', 'mult', 'fch', 'fch_decimal',
+                                            'filter_fir', 'filter_2', 'filter_5']
+                filter_resolution=conf.filter_resolution()
+                kwargs['resolution'] = filter_resolution
                 kwargs['status'] = conf.device.get_status_display()
                 kwargs['dev_conf'] = conf
                 kwargs['dev_conf_keys'] = ['name',
                                            'cards_number', 'channels_number', 'channels',
                                            #'rd_directory', 'pd_directory',
                                            'data_type',
                                            'acq_profiles', 'profiles_block', 'raw_data_blocks', 'ftp_interval', 'fftpoints',
                                            'cohe_integr_str', 'decode_data',
                                            'incohe_integr', 'cohe_integr', 'spectral_number',
                                            'spectral', 'create_directory', 'include_expname',
                                            'save_ch_dc', 'save_data']
                 kwargs['title'] = 'JARS Configuration'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Edit Configuration'
                 #kwargs['no_play'] = True
                 #kwargs['only_stop'] = True
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'jars_conf.html', kwargs)
             def jars_conf_edit(request, id_conf):
                 conf = get_object_or_404(JARSConfiguration, pk=id_conf)
+                filter_parms = eval(conf.filter_parms)
+                if filter_parms.__class__.__name__=='str':
+                    filter_parms = eval(filter_parms)
                 if request.method=='GET':
                     form = JARSConfigurationForm(instance=conf)
+                    filter_form = JARSfilterForm(initial=filter_parms)
                 if request.method=='POST':
                     form = JARSConfigurationForm(request.POST, instance=conf)
+                    filter_form = JARSfilterForm(request.POST)
+                    if filter_form.is_valid():
+                        jars_filter = filter_form.cleaned_data
+                        try:
+                            jars_filter.pop('name')
+                        except:
+                            pass
                     if form.is_valid():
                         conf = form.save(commit=False)
+                        conf.filter_parms = json.dumps(jars_filter)
                         conf.save()
                         return redirect('url_jars_conf', id_conf=conf.id)
-                        ##ERRORS
                 kwargs = {}
-                kwargs['filter_id'] = 1
                 kwargs['id_dev'] = conf.id
                 kwargs['form'] = form
+                kwargs['filter_form'] = filter_form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Save'
                 return render(request, 'jars_conf_edit.html', kwargs)
             def import_file(request, conf_id):
                 conf = get_object_or_404(JARSConfiguration, pk=conf_id)
                 if request.method=='POST':
                     form = JARSImportForm(request.POST, request.FILES)
                     if form.is_valid():
                         #try:
                         if True:
                             data = conf.import_from_file(request.FILES['file_name'])
                             conf.dict_to_parms(data)
                             messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
                             return redirect(conf.get_absolute_url_edit())
                         #except Exception as e:
                         #    messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], e))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = JARSImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'JARS Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'jars_import.html', kwargs)
             def read_conf(request, conf_id):
                 conf   = get_object_or_404(JARSConfiguration, pk=conf_id)
                 #filter = get_object_or_404(JARSfilter, pk=filter_id)
                 if request.method=='GET':
                     parms = conf.read_device()
                     conf.status_device()
                     if not parms:
                         messages.error(request, conf.message)
                         return redirect(conf.get_absolute_url())
                     form = JARSConfigurationForm(initial=parms, instance=conf)
                 if request.method=='POST':
                     form = JARSConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         form.save()
                         return redirect(conf.get_absolute_url())
                     messages.error(request, "Parameters could not be saved")
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['filter_id'] = conf.filter.id
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Parameters read from device'
                 kwargs['button'] = 'Save'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'jars_conf_edit.html', kwargs)
             def view_filter(request, conf_id, filter_id):
                 conf = get_object_or_404(JARSConfiguration, pk=conf_id)
                 filter = get_object_or_404(JARSfilter, pk=filter_id)
                 filter_parms       = eval(conf.filter_parms)
                 if filter_parms.__class__.__name__=='str':
                     filter_parms       = eval(filter_parms)
                 #filter.name        = filter_parms['name']
                 filter.clock       = filter_parms['clock']
                 filter.mult        = filter_parms['mult']
                 filter.fch         = filter_parms['fch']
                 filter.fch_decimal = filter_parms['fch_decimal']
                 filter.filter_fir  = filter_parms['filter_fir']
                 filter.filter_2    = filter_parms['filter_2']
                 filter.filter_5    = filter_parms['filter_5']
                 kwargs = {}
                 kwargs['conf']          = conf
                 kwargs['filter']        = filter
                 kwargs['dev_conf']      = filter
                 kwargs['dev_conf_keys'] = ['clock', 'mult', #'name',
                                            'fch', 'fch_decimal',
                                            'filter_2', 'filter_5',
                                            'filter_fir']
                 kwargs['title']         = 'Filter View'
                 kwargs['suptitle']      = 'Details'
                 kwargs['button']        = 'SI'
                 kwargs['edit_button']   = 'Edit Filter'
                 kwargs['add_button']    = 'New Filter'
                 return render(request, 'jars_filter.html', kwargs)
             def edit_filter(request, conf_id, filter_id):
                 conf = get_object_or_404(JARSConfiguration, pk=conf_id)
                 filter_parms = eval(conf.filter_parms)
                 if filter_id:
                     filter = get_object_or_404(JARSfilter, pk=filter_id)
                 if request.method=='GET':
                     form = JARSfilterForm(initial=filter_parms)
                 if request.method=='POST':
                     parms = {}
                     #parms['name']        = request.POST['name']
                     parms['clock']       = request.POST['clock']
                     parms['mult']        = request.POST['mult']
                     parms['fch']         = request.POST['fch']
                     parms['fch_decimal'] = request.POST['fch_decimal']
                     parms['filter_fir'] = request.POST['filter_fir']
                     parms['filter_2']   = request.POST['filter_2']
                     parms['filter_5']   = request.POST['filter_5']
                     conf.filter_parms = parms
                     conf.save()
                     #form = JARSfilterForm(request.POST)
                     #form = JARSfilterForm(request.POST, instance=filter)
                     #if form.is_valid():
                         #form.save()
                     #    messages.success(request, 'JARS Filter successfully updated')
                     #    return redirect('url_jars_filter', conf.id, filter.id)
                     return redirect('url_jars_filter', conf.id, filter.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = conf.name
                 kwargs['suptitle'] = 'Edit Filter'
                 kwargs['button'] = 'Save'
                # kwargs['previous'] = conf.get_absolute_url_edit()
                 kwargs['dev_conf'] = conf
                 return render(request, 'jars_filter_edit.html', kwargs)
             def new_filter(request, conf_id):
                 conf = get_object_or_404(JARSConfiguration, pk=conf_id)
                 if request.method=='GET':
                     form = JARSfilterForm()
                 if request.method=='POST':
                     form = JARSfilterForm(request.POST)
                     if form.is_valid():
                         form.save()
                         new_filter  = get_object_or_404(JARSfilter, name=request.POST['name'])
                         conf.filter = new_filter
                         conf.add_parms_to_filter()
                         messages.success(request, 'New JARS Filter successfully created')
                         return redirect('url_edit_jars_conf', id_conf=conf.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'New Filter'
                 kwargs['suptitle'] = ''
                 kwargs['button'] = 'Create'
                # kwargs['previous'] = conf.get_absolute_url_edit()
                 kwargs['dev_conf'] = conf
                 return render(request, 'jars_new_filter.html', kwargs)
+            def change_filter(request, conf_id, filter_id=None):
+                conf = get_object_or_404(JARSConfiguration, pk=conf_id)
+                if filter_id:
+                    if filter_id.__class__.__name__ not in ['int', 'float']:
+                        filter_id = eval(filter_id)
+                if filter_id == 0:
+                    return redirect('url_change_jars_filter', conf_id=conf.id)
+                if request.method=='GET':
+                    if not filter_id:
+                        form = JARSfilterForm(initial={'jars_configuration':conf_id, 'filter_id': 0})
+                    else:
+                        form = JARSfilterForm(initial={'jars_configuration':conf_id, 'filter_id': filter_id})
+                kwargs = {}
+                kwargs['title'] = 'JARS Configuration'
+                kwargs['suptitle'] = 'Change Filter'
+                kwargs['form'] = form
+                kwargs['conf_id'] = conf.id
+                kwargs['filter_id'] = filter_id
+                return render(request, 'change_jars_filter.html', kwargs)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages