radarsys Commit - r345:cf456d2fb627 · Jicamarca Repository

App JARS funcional

gonzalesluisfrancisco -

r345:cf456d2fb627

parent child

Context file:

r345:cf456d2fb627

Collapse all files

apps/jars/templates/jars_new_filter.html created 644 +2 0

@@ -0,0 +1,2
	1	{% extends "base_edit.html" %}
	2

README.md +1 -2

             # Integrated Radar System (SIR)
             The Integrated Radar System (SIR) is a web application that allows the configuration of the radar devices as required by the experiment,
             This app allows the creation of Campaigns, Experiment and Device Configurations.
-            For the python3.0 update please check the requeriments vrsion for each package. It depends on the python 3.7 or 3.8 version.
+            For the python3.0 update please check the requeriments vrsion for each package. It depends on the python 3.7 or 3.8 version. Special attention with the bokeh version.
-            Special attention with the bokeh version.
             For more information visit: http://jro-dev.igp.gob.pe:3000/projects/sistema-integrado-de-radar/wiki
             ## Installation
             We recommend use docker/docker-compose for test/production but you can install the aplication as a normal django app.
             ### 1. Download
             Download the application *radarsys* to your workspace
                 $ cd /path/to/your/workspace
                 $ git clone http://jro-dev.igp.gob.pe/rhodecode/radarsys && cd radarsys
             ### 2. Config app
             Update enviroment vars (/path/to/radarsys/.env)
                 REDIS_HOST=radarsys-redis
                 REDIS_PORT=6300
                 POSTGRES_DB_NAME=radarsys
                 POSTGRES_PORT_5432_TCP_ADDR=radarsys-postgres
                 POSTGRES_PORT_5432_TCP_PORT=5400
                 POSTGRES_USER=docker
                 POSTGRES_PASSWORD=****
                 PGDATA=/var/lib/postgresql/data
                 LC_ALL=C.UTF-8
             ### 3. Build application & make migrations (only once at installation)
                 $ cd /path/to/radarsys
                 $ docker-compose build
                 $ docker-compose run web python manage.py makemigrations
                 $ docker-compose run web python manage.py migrate
                 $ docker-compose run web python manage.py loaddata apps/main/fixtures/main_initial_data.json
                 $ docker-compose run web python manage.py loaddata apps/rc/fixtures/rc_initial_data.json
                 $ docker-compose run web python manage.py loaddata apps/jars/fixtures/initial_filters_data.json
                 $ docker-compose run web python manage.py collectstatic
             ### 4. Run containers
                 $ docker-compose up -d

apps/abs/views.py +16 -17

             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 django.conf import settings
             from django.http import HttpResponse
             from django.urls import reverse
             from django.views.decorators.csrf import csrf_exempt
             from django.utils.safestring import mark_safe
             from datetime import datetime
             from time import sleep
             import os
             import io
             from apps.main.models import Device, Configuration, Experiment
             from apps.main.views import sidebar
             from .models import ABSConfiguration, ABSBeam
             from .forms import ABSConfigurationForm, ABSBeamEditForm, ABSBeamAddForm, ABSImportForm
             from .utils.overJroShow import overJroShow
             #from .utils.OverJRO import OverJRO
-            # Create your views here.
+            #Create your views here.
             import json, ast
             def get_values_from_form(form_data):
                 sublistup     = []
                 sublistdown   = []
                 subtxlistup   = []
                 subtxlistdown = []
                 subrxlistup   = []
                 subrxlistdown = []
                 up_values_list     = []
                 down_values_list   = []
                 up_txvalues_list   = []
                 down_txvalues_list = []
                 up_rxvalues_list   = []
                 down_rxvalues_list = []
                 values_list = {}
                 cont = 1
                 for i in range(1,65):
                     x = float(form_data['abs_up'+str(i)])
                     y = float(form_data['abs_down'+str(i)])
                     sublistup.append(x)
                     sublistdown.append(y)
                     if str(i) in form_data.getlist('uptx_checks'):
                         subtxlistup.append(1)
                     else:
                         subtxlistup.append(0)
                     if str(i) in form_data.getlist('downtx_checks'):
                         subtxlistdown.append(1)
                     else:
                         subtxlistdown.append(0)
                     if str(i) in form_data.getlist('uprx_checks'):
                         subrxlistup.append(1)
                     else:
                         subrxlistup.append(0)
                     if str(i) in form_data.getlist('downrx_checks'):
                         subrxlistdown.append(1)
                     else:
                         subrxlistdown.append(0)
                     cont = cont+1
                     if cont == 9:
                         up_values_list.append(sublistup)
                         down_values_list.append(sublistdown)
                         sublistup   = []
                         sublistdown = []
                         up_txvalues_list.append(subtxlistup)
                         down_txvalues_list.append(subtxlistdown)
                         subtxlistup   = []
                         subtxlistdown = []
                         up_rxvalues_list.append(subrxlistup)
                         down_rxvalues_list.append(subrxlistdown)
                         subrxlistup   = []
                         subrxlistdown = []
                         cont = 1
                 list_uesup   = []
                 list_uesdown = []
                 for i in range(1,5):
                     if form_data['ues_up'+str(i)] == '':
                         list_uesup.append(0.0)
                     else:
                         list_uesup.append(float(form_data['ues_up'+str(i)]))
                     if form_data['ues_down'+str(i)] == '':
                         list_uesdown.append(0.0)
                     else:
                         list_uesdown.append(float(form_data['ues_down'+str(i)]))
                 onlyrx_list = form_data.getlist('onlyrx')
                 only_rx = {}
                 if '1' in onlyrx_list:
                     only_rx['up'] = True
                 else:
                     only_rx['up'] = False
                 if '2' in onlyrx_list:
                     only_rx['down'] = True
                 else:
                     only_rx['down'] = False
                 antenna = {'antenna_up': up_values_list, 'antenna_down': down_values_list}
                 tx      = {'up': up_txvalues_list, 'down': down_txvalues_list}
                 rx      = {'up': up_rxvalues_list, 'down': down_rxvalues_list}
                 ues     = {'up': list_uesup, 'down': list_uesdown}
                 name    = str(form_data['beam_name'])
                 beam_data = {'name': name, 'antenna': antenna, 'tx': tx, 'rx': rx, 'ues': ues, 'only_rx': only_rx}
                 return beam_data
             def abs_conf(request, id_conf):
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beams = ABSBeam.objects.filter(abs_conf=conf)
                 #------------Colors for Active Beam:-------------
                 all_status = {}
                 module_messages = json.loads(conf.module_messages)
                 color_status   = {}
                 for i, status in enumerate(conf.module_status):
                     if status == '3':    #Running background-color: #00cc00;
                         all_status['{}'.format(i+1)] = 2
                         color_status['{}'.format(i+1)] = 'class=text-success'#'bgcolor=#00cc00'
                     elif status == '2':
                         all_status['{}'.format(i+1)] = 1
                         color_status['{}'.format(i+1)] = 'class=text-info'
                     elif status == '1':  #Connected background-color: #ee902c;
                         all_status['{}'.format(i+1)] = 1
                         color_status['{}'.format(i+1)] = 'class=text-warning'#'bgcolor=#ee902c'
                     else:                #Disconnected background-color: #ff0000;
                         all_status['{}'.format(i+1)] = 0
                         color_status['{}'.format(i+1)] = 'class=text-danger'#'bgcolor=#FF0000'
                 #------------------------------------------------
                 kwargs = {}
                 kwargs['connected_modules'] = str(conf.connected_modules())+'/64'
                 kwargs['dev_conf'] = conf
                 if conf.operation_mode == 0:
                     kwargs['dev_conf_keys'] = ['label', 'operation_mode']
                 else:
                     kwargs['dev_conf_keys'] = ['label', 'operation_mode', 'operation_value']
                 kwargs['title'] = 'ABS Configuration'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Edit Configuration'
                 if conf.active_beam != 0:
                     kwargs['active_beam'] = int(conf.active_beam)
                 kwargs['beams'] = beams
                 kwargs['modules_status'] = all_status
                 kwargs['color_status']   = color_status
                 kwargs['module_messages'] = module_messages
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'abs_conf.html', kwargs)
             def abs_conf_edit(request, id_conf):
                 conf     = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beams = ABSBeam.objects.filter(abs_conf=conf)
                 if request.method=='GET':
                     form = ABSConfigurationForm(instance=conf)
                 if request.method=='POST':
                     form = ABSConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         conf = form.save(commit=False)
                         conf.save()
                         return redirect('url_abs_conf', id_conf=conf.id)
                 ###### SIDEBAR ######
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 #kwargs['id_dev'] = conf.id
                 kwargs['id_conf'] = conf.id
                 kwargs['form'] = form
                 kwargs['abs_beams'] = beams
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Save'
                 kwargs['edit'] = True
                 return render(request, 'abs_conf_edit.html', kwargs)
             @csrf_exempt
             def abs_conf_alert(request):
                 if request.method == 'POST':
                     print (request.POST)
                     return HttpResponse(json.dumps({'result':1}), content_type='application/json')
                 else:
                     return redirect('index')
             def import_file(request, id_conf):
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 if request.method=='POST':
                     form = ABSImportForm(request.POST, request.FILES)
                     if form.is_valid():
                         try:
                             parms = conf.import_from_file(request.FILES['file_name'])
                             if parms:
                                 conf.update_from_file(parms)
                                 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 = ABSImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'ABS Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'abs_import.html', kwargs)
             def send_beam(request, id_conf, id_beam):
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 abs = Configuration.objects.filter(pk=conf.device.conf_active).first()
                 if abs!=conf:
                     url = '#' if abs is None else abs.get_absolute_url()
                     label = 'None' if abs is None else abs.label
                     messages.warning(
                         request,
                         mark_safe('The current configuration has not been written in the modules, the active configuration is <a href="{}">{}</a>'.format(
                             url,
                             label
                             ))
                         )
                     return redirect(conf.get_absolute_url())
                 beam = get_object_or_404(ABSBeam, pk=id_beam)
                 if request.method == 'POST':
                     beams_list = ABSBeam.objects.filter(abs_conf=conf)
                     conf.active_beam = id_beam
                     i = 0
                     for b in beams_list:
                         if b.id == int(id_beam):
                             break
                         else:
                             i += 1
                     beam_pos = i + 1 #Estandarizar
                     print ('%s Position: %s') % (beam.name, str(beam_pos))
                     conf.send_beam(beam_pos)
                     return redirect('url_abs_conf', conf.id)
                 kwargs = {
                     'title': 'ABS',
                     'suptitle': conf.label,
                     'message': 'Are you sure you want to change ABS Beam to: {}?'.format(beam.name),
                     'delete': False
                 }
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             def add_beam(request, id_conf):
                 conf     = get_object_or_404(ABSConfiguration, pk=id_conf)
                 confs    = Configuration.objects.all()
                 if request.method=='GET':
                     form = ABSBeamAddForm()
                 if request.method=='POST':
                     form = ABSBeamAddForm(request.POST)
                     beam_data = get_values_from_form(request.POST)
                     new_beam = ABSBeam(
-                               name = beam_data['name'],
+                               name     = beam_data['name'],
-                               antenna = json.dumps(beam_data['antenna']),
+                               antenna  = json.dumps(beam_data['antenna']),
                                abs_conf = conf,
-                               tx = json.dumps(beam_data['tx']),
+                               tx       = json.dumps(beam_data['tx']),
-                               rx = json.dumps(beam_data['rx']),
+                               rx       = json.dumps(beam_data['rx']),
-                               ues = json.dumps(beam_data['ues']),
+                               ues      = json.dumps(beam_data['ues']),
-                               only_rx = json.dumps(beam_data['only_rx'])
+                               only_rx  = json.dumps(beam_data['only_rx'])
                                )
                     new_beam.save()
                     messages.success(request, 'Beam: "%s" has been added.'  % new_beam.name)
                     return redirect('url_edit_abs_conf', conf.id)
                 ###### SIDEBAR ######
                 kwargs = {}
-                #kwargs['dev_conf'] = conf.device
+                #kwargs['dev_conf']  = conf.device
-                #kwargs['id_dev'] = conf.device
+                #kwargs['id_dev']    = conf.device
-                kwargs['id_conf'] = conf.id
+                #kwargs['previous']  = conf.get_absolute_url_edit()
-                kwargs['form'] = form
+                kwargs['id_conf']    = conf.id
-                kwargs['title'] = 'ABS Beams'
+                kwargs['form']       = form
-                kwargs['suptitle'] = 'Add Beam'
+                kwargs['title']      = 'ABS Beams'
-                kwargs['button'] = 'Add'
+                kwargs['suptitle']   = 'Add Beam'
+                kwargs['button']     = 'Add'
                 kwargs['no_sidebar'] = True
+                kwargs['edit']       = True
-                #kwargs['previous'] = conf.get_absolute_url_edit()
-                kwargs['edit'] = True
                 return render(request, 'abs_add_beam.html', kwargs)
             def edit_beam(request, id_conf, id_beam):
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beam = get_object_or_404(ABSBeam, pk=id_beam)
                 if request.method=='GET':
                     form = ABSBeamEditForm(initial={'beam': beam})
                 if request.method=='POST':
                     form = ABSBeamEditForm(request.POST)
                     beam_data = get_values_from_form(request.POST)
                     beam.dict_to_parms(beam_data)
                     beam.save()
                     messages.success(request, 'Beam: "%s" has been updated.'  % beam.name)
                     return redirect('url_edit_abs_conf', conf.id)
                 ###### SIDEBAR ######
                 kwargs = {}
                 kwargs['id_conf'] = conf.id
                 kwargs['form'] = form
                 kwargs['title'] = 'ABS Beams'
                 kwargs['suptitle'] = 'Edit Beam'
                 kwargs['button'] = 'Save'
                 kwargs['no_sidebar'] = True
                 #kwargs['previous'] = conf.get_absolute_url_edit()
                 kwargs['edit'] = True
                 return render(request, 'abs_edit_beam.html', kwargs)
             def remove_beam(request, id_conf, id_beam):
                 conf     = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beam     = get_object_or_404(ABSBeam, pk=id_beam)
                 if request.method=='POST':
                     if beam:
                         try:
                             beam.delete()
                             messages.success(request, 'Beam: "%s" has been deleted.'  % beam)
                         except:
                             messages.error(request, 'Unable to delete beam: "%s".' % beam)
                     return redirect('url_edit_abs_conf', conf.id)
                 ###### SIDEBAR ######
                 kwargs = {}
                 kwargs['object'] = beam
                 kwargs['delete'] = True
                 kwargs['title'] = 'Delete'
                 kwargs['suptitle'] = 'Beam'
                 kwargs['previous'] = conf.get_absolute_url_edit()
                 return render(request, 'confirm.html', kwargs)
             def plot_patterns(request, id_conf, id_beam=None):
                 kwargs = {}
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beams = ABSBeam.objects.filter(abs_conf=conf)
                 if id_beam:
                     beam  = get_object_or_404(ABSBeam, pk=id_beam)
                     kwargs['beam'] = beam
                 ###### SIDEBAR ######
                 kwargs['dev_conf']   = conf.device
                 kwargs['id_dev']     = conf.device
                 kwargs['id_conf']    = conf.id
                 kwargs['abs_beams']  = beams
                 kwargs['title']      = 'ABS Patterns'
                 kwargs['suptitle']   = conf.name
                 kwargs['no_sidebar'] = True
                 return render(request, 'abs_patterns.html', kwargs)
             def plot_pattern(request, id_conf, id_beam, antenna):
                 if antenna=='down':
                     sleep(3)
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beam = get_object_or_404(ABSBeam, pk=id_beam)
                 just_rx = 1 if json.loads(beam.only_rx)[antenna] else 0
                 phases = json.loads(beam.antenna)['antenna_{}'.format(antenna)]
                 gain_tx = json.loads(beam.tx)[antenna]
                 gain_rx = json.loads(beam.rx)[antenna]
                 ues = json.loads(beam.ues)[antenna]
                 newOverJro = overJroShow(beam.name)
                 fig = newOverJro.plotPattern2(datetime.today(), phases, gain_tx, gain_rx, ues, just_rx)
                 buf = io.BytesIO()
                 fig.savefig(buf, format='png')
                 response = HttpResponse(buf.getvalue(), content_type='image/png')
                 return response

apps/jars/forms.py +11 -2

             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)
+                choices = add_empty_choice(choices,label="New Choice")
                 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')
                         self.fields['device'].widget.choices = [(device.id, device) for device in devices]
                     self.fields['spectral_number'].widget.attrs['readonly'] = True
                     self.fields['spectral'].widget = SpectralWidget()
                 class Meta:
                     model = JARSConfiguration
                     exclude = ('type', 'parameters', 'status', 'filter_parms', 'author', 'hash', 'filter')
             class JARSFilterForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(JARSFilterForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     self.fields['f_decimal'].widget.attrs['readonly'] = True
                     if 'initial' in kwargs:
                         self.fields['filter_template'] = forms.ChoiceField(
-                            choices=create_choices_from_model(JARSFilter),
+                            choices = create_choices_from_model(JARSFilter),
                             initial = kwargs['initial']['id']
                         )
                         # self.fields['name'].initial = kwargs['initial']['id']
                             # 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']:
                             #         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 = ('name', )
+            class JARSFilterFormNew(forms.ModelForm):
+                def __init__(self, *args, **kwargs):
+                    super(JARSFilterFormNew, self).__init__(*args, **kwargs)
+                    self.fields['f_decimal'].widget.attrs['readonly'] = True
+                class Meta:
+                    model = JARSFilter
+                    exclude = ()
             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'])

apps/jars/models.py +89 -74

             import json
             import requests
             from django.db import models
             from django.core.validators import MinValueValidator, MaxValueValidator
             from django.urls import reverse
             from apps.main.models import Configuration
             from apps.main.utils import Params
             from .utils import create_jarsfiles
             # 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'),
             )
             FILTER = '{"id":1, "clock": 60, "multiplier": 5, "frequency": 49.92, "f_decimal":	721554506, "fir": 2, "cic_2": 12, "cic_5": 25}'
             class JARSFilter(models.Model):
-                JARS_NBITS = 32
+                JARS_NBITS  = 32
-                name = models.CharField(verbose_name='Name', max_length=60, unique=True, default='')
+                name        = models.CharField(verbose_name='Name', max_length=60, unique=True, default='')
-                clock = models.FloatField(verbose_name='Clock In (MHz)', validators=[
+                clock       = models.FloatField(verbose_name='Clock In (MHz)', validators=[
                                           MinValueValidator(5), MaxValueValidator(75)], null=True, default=60)
-                multiplier = models.PositiveIntegerField(verbose_name='Multiplier', validators=[
+                multiplier  = models.PositiveIntegerField(verbose_name='Multiplier', validators=[
                                                          MinValueValidator(1), MaxValueValidator(20)], default=5)
-                frequency = models.FloatField(verbose_name='Frequency (MHz)', validators=[
+                frequency   = models.FloatField(verbose_name='Frequency (MHz)', validators=[
                                               MaxValueValidator(150)], null=True, default=49.9200)
-                f_decimal = models.BigIntegerField(verbose_name='Frequency (Decimal)', validators=[
+                f_decimal   = models.BigIntegerField(verbose_name='Frequency (Decimal)', validators=[
                                                    MinValueValidator(-9223372036854775808), MaxValueValidator(2**JARS_NBITS-1)], null=True, default=721554505)
-                cic_2 = models.PositiveIntegerField(verbose_name='CIC2', validators=[
+                cic_2       = models.PositiveIntegerField(verbose_name='CIC2', validators=[
                                                     MinValueValidator(2), MaxValueValidator(100)], default=10)
                 scale_cic_2 = models.PositiveIntegerField(verbose_name='Scale CIC2', validators=[
                                                           MinValueValidator(0), MaxValueValidator(6)], default=1)
-                cic_5 = models.PositiveIntegerField(verbose_name='CIC5', validators=[
+                cic_5       = models.PositiveIntegerField(verbose_name='CIC5', validators=[
                                                     MinValueValidator(1), MaxValueValidator(100)], default=1)
                 scale_cic_5 = models.PositiveIntegerField(verbose_name='Scale CIC5', validators=[
                                                           MinValueValidator(0), MaxValueValidator(20)], default=5)
-                fir = models.PositiveIntegerField(verbose_name='FIR', validators=[
+                fir         = models.PositiveIntegerField(verbose_name='FIR', validators=[
                                                   MinValueValidator(1), MaxValueValidator(100)], default=6)
-                scale_fir = models.PositiveIntegerField(verbose_name='Scale FIR', validators=[
+                scale_fir   = models.PositiveIntegerField(verbose_name='Scale FIR', validators=[
                                                         MinValueValidator(0), MaxValueValidator(7)], default=3)
                 number_taps = models.PositiveIntegerField(verbose_name='Number of taps', validators=[
                                                           MinValueValidator(1), MaxValueValidator(256)], default=4)
-                taps = models.CharField(verbose_name='Taps', max_length=1600, default='0')
+                taps        = models.CharField(verbose_name='Taps', max_length=1600, default='0')
                 class Meta:
                     db_table = 'jars_filters'
                 def __unicode__(self):
                     return u'%s' % (self.name)
                 def jsonify(self):
-                    data = {}
+                    data    = {}
                     ignored = ()
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     return data
                 def parms_to_dict(self):
                     parameters = {}
-                    parameters['name'] = self.name
+                    parameters['name']       = self.name
-                    parameters['clock'] = float(self.clock)
+                    parameters['clock']      = float(self.clock)
                     parameters['multiplier'] = int(self.multiplier)
-                    parameters['frequency'] = float(self.frequency)
+                    parameters['frequency']  = float(self.frequency)
-                    parameters['f_decimal'] = int(self.frequency)
+                    parameters['f_decimal']  = int(self.frequency)
-                    parameters['fir'] = int(self.fir)
+                    parameters['fir']        = int(self.fir)
-                    parameters['cic_2'] = int(self.cic_2)
+                    parameters['cic_2']      = int(self.cic_2)
-                    parameters['cic_5'] = int(self.cic_5)
+                    parameters['cic_5']      = int(self.cic_5)
                     return parameters
                 def dict_to_parms(self, parameters):
-                    self.name = parameters['name']
+                    self.name       = parameters['name']
-                    self.clock = parameters['clock']
+                    self.clock      = parameters['clock']
                     self.multiplier = parameters['multiplier']
-                    self.frequency = parameters['frequency']
+                    self.frequency  = parameters['frequency']
-                    self.f_decimal = parameters['f_decimal']
+                    self.f_decimal  = parameters['f_decimal']
-                    self.fir = parameters['fir']
+                    self.fir        = parameters['fir']
-                    self.cic_2 = parameters['cic_2']
+                    self.cic_2      = parameters['cic_2']
-                    self.cic_5 = parameters['cic_5']
+                    self.cic_5      = parameters['cic_5']
+                def dict_to_parms_new(self, parameters):
+                    self.name        = parameters['name']
+                    self.clock       = parameters['clock']
+                    self.multiplier  = parameters['multiplier']
+                    self.frequency   = parameters['frequency']
+                    self.f_decimal   = parameters['f_decimal']
+                    self.fir         = parameters['fir']
+                    self.cic_2       = parameters['cic_2']
+                    self.cic_5       = parameters['cic_5']
+                    self.scale_fir   = parameters['scale_fir']
+                    self.scale_cic_2 = parameters['scale_cic_2']
+                    self.scale_cic_5 = parameters['scale_cic_5']
+                    self.number_taps = parameters['number_taps']
+                    self.taps        = parameters['taps']
             class JARSConfiguration(Configuration):
-                ADC_RESOLUTION = 8
+                ADC_RESOLUTION   = 8
                 PCI_DIO_BUSWIDTH = 32
-                HEADER_VERSION = 1103
+                HEADER_VERSION   = 1103
-                BEGIN_ON_START = True
+                BEGIN_ON_START   = True
-                REFRESH_RATE = 1
+                REFRESH_RATE     = 1
-                exp_type = models.PositiveIntegerField(
+                exp_type         = models.PositiveIntegerField(
                     verbose_name='Experiment Type', choices=EXPERIMENT_TYPE, default=0)
-                cards_number = models.PositiveIntegerField(verbose_name='Number of Cards', validators=[
+                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=[
+                channels_number  = models.PositiveIntegerField(verbose_name='Number of Channels', validators=[
                                                               MinValueValidator(1), MaxValueValidator(8)], default=5)
-                channels = models.CharField(
+                channels         = models.CharField(
                     verbose_name='Channels', max_length=15, default='1,2,3,4,5')
-                data_type = models.PositiveIntegerField(
+                data_type        = models.PositiveIntegerField(
                     verbose_name='Data Type', choices=DATA_TYPE, default=0)
-                raw_data_blocks = models.PositiveIntegerField(
+                raw_data_blocks  = models.PositiveIntegerField(
                     verbose_name='Raw Data Blocks', validators=[MaxValueValidator(5000)], default=60)
-                profiles_block = models.PositiveIntegerField(
+                profiles_block   = models.PositiveIntegerField(
                     verbose_name='Profiles Per Block', default=400)
-                acq_profiles = models.PositiveIntegerField(
+                acq_profiles     = models.PositiveIntegerField(
                     verbose_name='Acquired Profiles', default=400)
-                ftp_interval = models.PositiveIntegerField(
+                ftp_interval     = models.PositiveIntegerField(
                     verbose_name='FTP Interval', default=60)
-                fftpoints = models.PositiveIntegerField(
+                fftpoints        = models.PositiveIntegerField(
                     verbose_name='FFT Points', default=16)
-                cohe_integr_str = models.PositiveIntegerField(
+                cohe_integr_str  = models.PositiveIntegerField(
                     verbose_name='Coh. Int. Stride', validators=[MinValueValidator(1)], default=30)
-                cohe_integr = models.PositiveIntegerField(
+                cohe_integr      = models.PositiveIntegerField(
                     verbose_name='Coherent Integrations', validators=[MinValueValidator(1)], default=30)
-                incohe_integr = models.PositiveIntegerField(
+                incohe_integr    = models.PositiveIntegerField(
                     verbose_name='Incoherent Integrations', validators=[MinValueValidator(1)], default=30)
-                decode_data = models.PositiveIntegerField(
+                decode_data      = models.PositiveIntegerField(
                     verbose_name='Decode Data', choices=DECODE_TYPE, default=0)
-                post_coh_int = models.BooleanField(
+                post_coh_int     = models.BooleanField(
                     verbose_name='Post Coherent Integration', default=False)
-                spectral_number = models.PositiveIntegerField(
+                spectral_number  = models.PositiveIntegerField(
                     verbose_name='# Spectral Combinations', validators=[MinValueValidator(1)], default=1)
-                spectral = models.CharField(
+                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(
+                include_expname  = models.BooleanField(
                     verbose_name='Experiment Name in Directory', default=False)
                 #view_raw_data    = models.BooleanField(verbose_name='View Raw Data', default=True)
-                save_ch_dc = models.BooleanField(
+                save_ch_dc       = models.BooleanField(
                     verbose_name='Save Channels DC', default=True)
-                save_data = models.BooleanField(verbose_name='Save Data', default=True)
+                save_data        = models.BooleanField(verbose_name='Save Data', default=True)
-                filter_parms = models.CharField(
+                filter_parms     = models.CharField(
                     max_length=10000, default=FILTER)
-                filter = models.ForeignKey(
+                filter           = models.ForeignKey(
                     'JARSFilter', verbose_name='Filter', null=True, blank=True, on_delete=models.CASCADE)
                 class Meta:
                     db_table = 'jars_configurations'
                 def filter_resolution(self):
                     filter_parms = json.loads(self.filter_parms)
-                    clock = float(filter_parms['clock'])
+                    clock        = float(filter_parms['clock'])
-                    cic_2 = filter_parms['cic_2']
+                    cic_2        = filter_parms['cic_2']
-                    cic_5 = filter_parms['cic_5']
+                    cic_5        = filter_parms['cic_5']
-                    fir = filter_parms['fir']
+                    fir          = filter_parms['fir']
-                    resolution = round((clock/(cic_2*cic_5*fir)), 2)
+                    resolution   = round((clock/(cic_2*cic_5*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')
                         data['filter_parms'] = params['filter_parms']
                     # self.name = data['name']
                     self.exp_type = data['exp_type']
                     #----PDATA----
                     if self.exp_type == 1:
-                        self.incohe_integr = data['incohe_integr']
+                        self.incohe_integr   = data['incohe_integr']
                         self.spectral_number = data['spectral_number']
-                        self.spectral = data['spectral']
+                        self.spectral        = data['spectral']
-                        self.fftpoints = data['fftpoints']
+                        self.fftpoints       = data['fftpoints']
-                        self.save_ch_dc = data['save_ch_dc']
+                        self.save_ch_dc      = data['save_ch_dc']
                     else:
                         self.raw_data_blocks = data['raw_data_blocks']
                     #----PDATA----
-                    self.cards_number = data['cards_number']
+                    self.cards_number    = data['cards_number']
                     self.channels_number = data['channels_number']
-                    self.channels = data['channels']
+                    self.channels        = data['channels']
-                    self.data_type = data['data_type']
+                    self.data_type       = data['data_type']
-                    self.profiles_block = data['profiles_block']
+                    self.profiles_block  = data['profiles_block']
-                    self.acq_profiles = data['acq_profiles']
+                    self.acq_profiles    = data['acq_profiles']
-                    self.ftp_interval = data['ftp_interval']
+                    self.ftp_interval    = data['ftp_interval']
                     self.cohe_integr_str = data['cohe_integr_str']
-                    self.cohe_integr = data['cohe_integr']
+                    self.cohe_integr     = data['cohe_integr']
                     #----DECODE----
-                    self.decode_data = data['decode_data']
+                    self.decode_data  = data['decode_data']
                     self.post_coh_int = data['post_coh_int']
                     #----DECODE----
                     self.create_directory = data['create_directory']
-                    self.include_expname = data['include_expname']
+                    self.include_expname  = data['include_expname']
-                    self.save_data = data['save_data']
+                    self.save_data        = data['save_data']
-                    self.filter_parms = json.dumps(data['filter_parms'])
+                    self.filter_parms     = json.dumps(data['filter_parms'])
                     self.save()
                 def parms_to_text(self, file_format='jars'):
                     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 = 'File needs RC configuration'
                         return ''
                     json_data = json.dumps(data)
                     racp_file, filter_file = create_jarsfiles(json_data)
                     if file_format == 'racp':
                         return racp_file
                     return filter_file
                 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()
+                    #print(data)
                     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'] == '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']
                     if len(rc_ids) == 0:
                         self.message = 'Missing RC configuration'
                         return False
                     json_data = json.dumps(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 get_log(self):
                     payload = None
                     try:
                         payload = requests.get(self.device.url('get_log'), params={
                                                'name': self.experiment.name})
                     except:
                         self.device.status = 0
                         self.device.save()
                         self.message = 'Jars API is not running.'
                         return False
                     self.message = 'Jars API is running'
                     return payload
                 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)])
                 def get_absolute_url_log(self):
                     return reverse('url_get_jars_log', args=[str(self.id)])

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

             {% extends "base.html" %}
-            {% load bootstrap3 %}
+            {% load bootstrap4 %}
             {% block mainactive %}active{% endblock %}
             {% block content-title %}Acquisition System{% endblock %}
             {% block content-suptitle %}JARS{% endblock %}
             {% block content %}
             <form class="form" method="post" action="">
             {% csrf_token %}
             {% bootstrap_form form layout='horizontal' size='medium' %}
             <div style="clear: both;"></div>
             <br>
             <button type="submit" class="btn btn-primary pull-right" id="bt_update">Update</button>
             </form>
             {% endblock %}
             {% block sidebar%}
             {% include "sidebar_devices.html" %}
             {% endblock %}

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

             {% extends "dev_conf.html" %}
             {% load static %}
-            {% load bootstrap3 %}
+            {% load bootstrap4 %}
             {% load main_tags %}
             {% block extra-menu-actions %}
             <li><a href="{{ dev_conf.get_absolute_url_log }}"><span class="fas fa-save" aria-hidden="true"></span>
                     Get Log File</a></li>
             {% endblock %}
             {% block extra-content %}
             <div class="clearfix"></div>
             <h2>Filter: {{resolution}}</h2>
             <br>
             <table class="table table-bordered">
                 {% for key in filter_keys %}
                 <tr>
                     <th>{% get_verbose_field_name filter_obj key %}</th>
                     <td>{{filter|attr:key}}</td>
                 </tr>
                 {% endfor %}
             </table>
             {% endblock extra-content%}

apps/jars/templates/jars_conf_edit.html +5 -2

             {% extends "dev_conf_edit.html" %}
-            {% load bootstrap3 %}
+            {% load bootstrap4 %}
             {% 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>
               <h2>Filter <small>{{filter_name}}</small></h2>
               <br>
               {% 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="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 src="{% static 'js/filters.js' %}"></script>
             <script type="text/javascript">
               $("#bt_cancel").click(function () {
                 document.location = "{% url 'url_jars_conf' id_dev %}";
               });
               $("#id_filter_template").change(function () {
-                document.location = "{% url 'url_change_jars_filter' id_dev %}" + $("#id_filter_template").val();
+                if($("#id_filter_template").val()!=0)
+                  document.location = "{% url 'url_change_jars_filter' id_dev %}" + $("#id_filter_template").val();
+                else
+                  document.location = "{% url 'url_new_jars_filter' id_dev %}"
               });
             </script>
             {% endblock %}

apps/jars/urls.py +1 0

             from django.urls import path
             from . import views
             urlpatterns = (
                 path('<int:id_conf>/', views.jars_conf, name='url_jars_conf'),
                 path('<int:id_conf>/edit/', views.jars_conf_edit, name='url_edit_jars_conf'),
                 path('<int:conf_id>/change_filter/', views.change_filter, name='url_change_jars_filter'),
                 path('<int:conf_id>/change_filter/<int:filter_id>/', views.change_filter, name='url_change_jars_filter'),
+                path('<int:conf_id>/new_filter/', views.new_filter, name='url_new_jars_filter'),
                 path('<int:conf_id>/import/', views.import_file, name='url_import_jars_conf'),
                 path('<int:conf_id>/read/', views.read_conf, name='url_read_jars_conf'),
                 path('<int:conf_id>/get_log/', views.get_log, name='url_get_jars_log'),
             )

apps/jars/views.py +56 -29

             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 django.http import HttpResponse
             from apps.main.models import Device
             from apps.main.views import sidebar
             from .models import JARSConfiguration, JARSFilter
-            from .forms import JARSConfigurationForm, JARSFilterForm, JARSImportForm
+            from .forms import JARSConfigurationForm, JARSFilterForm, JARSImportForm,JARSFilterFormNew
             import json
             # Create your views here.
             def jars_conf(request, id_conf):
                 conf = get_object_or_404(JARSConfiguration, pk=id_conf)
                 filter_parms = json.loads(conf.filter_parms)
                 kwargs = {}
-                kwargs['filter'] = filter_parms
+                kwargs['filter']       = filter_parms
-                kwargs['filter_obj'] = JARSFilter.objects.get(pk=1)
+                kwargs['filter_obj']   = JARSFilter.objects.get(pk=1)
                 kwargs['filter_keys']  = ['clock', 'multiplier', 'frequency', 'f_decimal',
                                           'cic_2', 'scale_cic_2', 'cic_5', 'scale_cic_5', 'fir',
                                           'scale_fir', 'number_taps', 'taps']
-                filter_resolution = conf.filter_resolution()
+                filter_resolution      = conf.filter_resolution()
-                kwargs['resolution'] = '{} (MHz)'.format(filter_resolution)
+                kwargs['resolution']   = '{} (MHz)'.format(filter_resolution)
                 if filter_resolution < 1:
                     kwargs['resolution'] = '{} (kHz)'.format(filter_resolution*1000)
-                kwargs['status'] = conf.device.get_status_display()
+                kwargs['status']        = conf.device.get_status_display()
-                kwargs['dev_conf'] = conf
+                kwargs['dev_conf']      = conf
                 kwargs['dev_conf_keys'] = ['cards_number', 'channels_number', 'channels',
                                            'ftp_interval', 'data_type','acq_profiles',
                                            'profiles_block', 'raw_data_blocks', 'ftp_interval',
                                            'cohe_integr_str', 'cohe_integr', 'decode_data', 'post_coh_int',
                                            'incohe_integr', 'fftpoints', 'spectral_number',
                                            'spectral', 'create_directory', 'include_expname',
                                            'save_ch_dc', 'save_data']
                 if conf.exp_type == 0:
                     for field in ['incohe_integr','fftpoints','spectral_number', 'spectral', 'save_ch_dc']:
                         kwargs['dev_conf_keys'].remove(field)
                 if conf.decode_data == 0:
                     kwargs['dev_conf_keys'].remove('decode_data')
                     kwargs['dev_conf_keys'].remove('post_coh_int')
                 kwargs['title'] = 'JARS Configuration'
                 kwargs['suptitle'] = 'Details'
                 ###### 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)
+                conf         = get_object_or_404(JARSConfiguration, pk=id_conf)
                 filter_parms = json.loads(conf.filter_parms)
                 if request.method=='GET':
-                    form = JARSConfigurationForm(instance=conf)
+                    form        = JARSConfigurationForm(instance=conf)
                     filter_form = JARSFilterForm(initial=filter_parms)
                 if request.method=='POST':
-                    form = JARSConfigurationForm(request.POST, instance=conf)
+                    form        = JARSConfigurationForm(request.POST, instance=conf)
                     filter_form = JARSFilterForm(request.POST)
                     if filter_form.is_valid():
-                       jars_filter = filter_form.cleaned_data
+                       jars_filter       = filter_form.cleaned_data
                        jars_filter['id'] = request.POST['filter_template']
                     else:
                        messages.error(request, filter_form.errors)
                     if form.is_valid():
-                        conf = form.save(commit=False)
+                        conf              = form.save(commit=False)
                         conf.filter_parms = json.dumps(jars_filter)
                         conf.save()
                         return redirect('url_jars_conf', id_conf=conf.id)
                 kwargs = {}
-                kwargs['id_dev'] = conf.id
+                kwargs['id_dev']      = conf.id
-                kwargs['form'] = form
+                kwargs['form']        = form
                 kwargs['filter_form'] = filter_form
                 kwargs['filter_name'] = JARSFilter.objects.get(pk=filter_parms['id']).name
-                kwargs['title'] = 'Device Configuration'
+                kwargs['title']       = 'Device Configuration'
-                kwargs['suptitle'] = 'Edit'
+                kwargs['suptitle']    = 'Edit'
-                kwargs['button'] = 'Save'
+                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:
                             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'], repr(e)))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = JARSImportForm()
                 kwargs = {}
-                kwargs['form'] = form
+                kwargs['form']     = form
-                kwargs['title'] = 'JARS Configuration'
+                kwargs['title']    = 'JARS Configuration'
                 kwargs['suptitle'] = 'Import file'
-                kwargs['button'] = 'Upload'
+                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['id_dev']    = conf.id
                 kwargs['filter_id'] = conf.filter.id
-                kwargs['form'] = form
+                kwargs['form']      = form
-                kwargs['title'] = 'Device Configuration'
+                kwargs['title']     = 'Device Configuration'
-                kwargs['suptitle'] = 'Parameters read from device'
+                kwargs['suptitle']  = 'Parameters read from device'
-                kwargs['button'] = 'Save'
+                kwargs['button']    = 'Save'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'jars_conf_edit.html', kwargs)
+            def new_filter(request, conf_id):
+                conf         = get_object_or_404(JARSConfiguration, pk=conf_id)
+                form         = JARSFilterFormNew()
+                if request.method=='POST':
+                    filter_form = JARSFilterFormNew(request.POST)
+                    if filter_form.is_valid():
+                       jars_filter       = filter_form.cleaned_data
+                       jars_filter['id'] = request.POST['name']
+                    else:
+                       messages.error(request, filter_form.errors)
+                    #print(json.dumps(jars_filter))
+                    jars_filter_obj       = JARSFilter()
+                    jars_filter_obj.dict_to_parms_new(request.POST)
+                    jars_filter_obj.save()
+                    return redirect('url_edit_jars_conf', id_conf=conf.id)
+                kwargs = {}
+                kwargs['id_dev']    = conf.id
+                kwargs['form']      = form
+                kwargs['title']     = 'New JARS Filter'
+                kwargs['suptitle']  = 'Parameters'
+                kwargs['button']    = 'Save'
+                return render(request, 'jars_new_filter.html', kwargs)
             def change_filter(request, conf_id, filter_id):
-                conf = get_object_or_404(JARSConfiguration, pk=conf_id)
+                conf              = get_object_or_404(JARSConfiguration, pk=conf_id)
-                filter = get_object_or_404(JARSFilter, pk=filter_id)
+                filter            = get_object_or_404(JARSFilter, pk=filter_id)
                 conf.filter_parms = json.dumps(filter.jsonify())
                 conf.save()
                 return redirect('url_edit_jars_conf', id_conf=conf.id)
             def get_log(request, conf_id):
                 conf = get_object_or_404(JARSConfiguration, pk=conf_id)
                 response = conf.get_log()
                 if not response:
                     message = conf.message
                     messages.error(request, message)
                     return redirect('url_jars_conf', id_conf=conf.id)
                 try:
                     message = response.json()['message']
                     messages.error(request, message)
                     return redirect('url_jars_conf', id_conf=conf.id)
                 except Exception as e:
-                    message = 'Restarting Report.txt has been downloaded successfully.'
+                    message = 'Restarting Report.txt has been downloaded successfully.'+e
                 content = response
                 filename     =  'Log_%s_%s.txt' %(conf.experiment.name, conf.experiment.id)
                 response = HttpResponse(content,content_type='text/plain')
                 response['Content-Disposition'] = 'attachment; filename="%s"' %filename
                 return response

apps/jars/widgets.py +2 -2

             import ast
             import json
             from itertools import chain
             from django import forms
             from django.utils.safestring import mark_safe
             from django.utils.html import conditional_escape
             class SpectralWidget(forms.widgets.TextInput):
-                def render(self, label, value, attrs=None):
+                def render(self, name, value, attrs=None, renderer=None):
+                    label = name
                     readonly = 'readonly' if attrs.get('readonly', False) else ''
                     name = attrs.get('name', label)
                     if value == None:
                         value = '[0, 0],'
                     if '[' in value:
                         if value[len(value)-1] == ",":
                             value = ast.literal_eval(value)
                         else:
                             value = value + ","
                             value = ast.literal_eval(value)
                     codes = value
                     if not isinstance(value, list):
                         text=''
                         #lista = []
                         #if len(value) > 1:
                         for val in value:
                             text = text+str(val)+','
                             #lista.append(val)
                         codes=text
                     else:
                         codes=''
                     html = '''<textarea rows="5" {0} class="form-control" id="id_{1}" name="{2}" style="white-space:nowrap; overflow:scroll;">{3}</textarea>
                               <input type="text" class="col-md-1 col-no-padding" id="num1" value=0>
                               <input type="text" class="col-md-1 col-no-padding" id="num2" value=0>
                               <button type="button" class="button" id="add_spectral_button"> Add </button>
                               <button type="button" class="button" id="delete_spectral_button"> Delete </button>
                               <button type="button" class="button pull-right" id="cross_spectral_button"> Cross </button>
                               <button type="button" class="button pull-right" id="self_spectral_button"> Self </button>
                               <button type="button" class="button pull-right" id="all_spectral_button"> All </button>
                               '''.format(readonly, label, name, codes)
                     script = '''
                             <script type="text/javascript">
                             $(document).ready(function () {{
                                 var spectral_number1 = $("#num1").val();
                                 var spectral_number2 = $("#num2").val();
                                 $("#all_spectral_button").click(function(){{
                                     var sequence1 = selfSpectral()
                                     var sequence2 = crossSpectral()
                                     $("#id_spectral").val(sequence1+sequence2)
                                     updateSpectralNumber()
                                 }});
                                 $("#add_spectral_button").click(function(){{
                                     var spectral_comb = $("#id_spectral").val();
                                     var spectral_number1 = $("#num1").val();
                                     var spectral_number2 = $("#num2").val();
                                     var str = spectral_number1+", "+spectral_number2;
                                     //not to duplicate
                                     var n = spectral_comb.search(str);
                                     if (n==-1){
                                         $("#id_spectral").val(spectral_comb+"["+$("#num1").val()+", "+$("#num2").val()+"],")
                                     }
                                     updateSpectralNumber()
                                 }});
                                 $("#self_spectral_button").click(function(){{
                                     var sequence = selfSpectral()
                                     $("#id_spectral").val(sequence)
                                     updateSpectralNumber()
                                 }});
                                 $("#cross_spectral_button").click(function(){{
                                     var sequence = crossSpectral()
                                     $("#id_spectral").val(sequence)
                                     updateSpectralNumber()
                                 }});
                                 function selfSpectral() {
                                     var channels = $("#id_channels").val();
                                     var n = (channels.length)-1;
                                     var num = parseInt(channels[n]);
                                     sequence = ""
                                     for (i = 0; i < num; i++) {
                                         sequence = sequence + "[" + i.toString() + ", " + i.toString() + "],"
                                     }
                                     return sequence
                                 }
                                 function crossSpectral() {
                                     var channels = $("#id_channels").val();
                                     var n = (channels.length)-1;
                                     var num = parseInt(channels[n]);
                                     sequence = ""
                                     for (i = 0; i < num; i++) {
                                         for (j = i+1; j < num; j++) {
                                         sequence = sequence + "[" + i.toString() + ", " + j.toString() + "],"
                                         }
                                     }
                                     return sequence
                                 }
                                 function updateSpectralNumber(){
                                     var spectral_comb = $("#id_spectral").val();
                                     var num = spectral_comb.length;
                                     var cont = 0
                                     for (i = 0; i < num; i++) {
                                         if (spectral_comb[i] == "]"){
                                             cont = cont + 1
                                         }
                                     }
                                     $("#id_spectral_number").val(cont)
                                 }
                                 $("#delete_spectral_button").click(function(){{
                                     var spectral_comb = $("#id_spectral").val();
                                     var spectral_number1 = $("#num1").val();
                                     var spectral_number2 = $("#num2").val();
                                     var str = spectral_number1+", "+spectral_number2;
                                     var n = spectral_comb.search(str);
                                     if (n==-1){
                                     }
                                     else {
                                         n= spectral_comb.length;
                                         if (n<8){
                                             var tuple = "["+$("#num1").val()+", "+$("#num2").val()+"],"
                                             var txt = spectral_comb.replace(tuple,'');
                                         }
                                         else {
                                             var tuple = ",["+$("#num1").val()+", "+$("#num2").val()+"]"
                                             var txt = spectral_comb.replace(tuple,'');
                                         }
                                         $("#id_spectral").val(txt)
                                         var tuple = "["+$("#num1").val()+", "+$("#num2").val()+"],"
                                         var txt = spectral_comb.replace(tuple,'');
                                         $("#id_spectral").val(txt)
                                     }
                                     updateSpectralNumber()
                                 }});
                             }});
                             </script>
                             '''
                     return mark_safe(html+script)

apps/main/models.py +8 0

             import os
             import json
             import requests
             import time
             from datetime import datetime
             try:
                 from polymorphic.models import PolymorphicModel
             except:
                 from polymorphic import PolymorphicModel
             from django.template.base import kwarg_re
             from django.db import models
             from django.urls import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from django.shortcuts import get_object_or_404
             from django.contrib.auth.models import User
             from django.db.models.signals import post_save
             from django.dispatch import receiver
             from apps.main.utils import Params
             from apps.rc.utils import RCFile
             from apps.jars.utils import RacpFile
             from devices.dds import api as dds_api
             from devices.dds import data as dds_data
             DEV_PORTS = {
                             'rc'    : 2000,
                             'dds'   : 2000,
                             'jars'  : 2000,
                             'usrp'  : 2000,
                             'cgs'   : 8080,
                             'abs'   : 8080,
                             'dds_rest': 80
                         }
             RADAR_STATES = (
                              (0, 'No connected'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                              (4, 'Scheduled'),
                          )
             EXPERIMENT_TYPE = (
                                (0, 'RAW_DATA'),
                                (1, 'PDATA'),
                                )
             DECODE_TYPE = (
                          (0, 'None'),
                          (1, 'TimeDomain'),
                          (2, 'FreqDomain'),
                          (3, 'InvFreqDomain'),
                          )
             DEV_STATES = (
                              (0, 'No connected'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                              (4, 'Unknown'),
                          )
             DEV_TYPES = (
                             ('', 'Select a device type'),
                             ('rc', 'Radar Controller'),
                             ('dds', 'Direct Digital Synthesizer'),
                             ('jars', 'Jicamarca Radar Acquisition System'),
                             ('usrp', 'Universal Software Radio Peripheral'),
                             ('cgs', 'Clock Generator System'),
                             ('abs', 'Automatic Beam Switching'),
                             ('dds_rest', 'Direct Digital Synthesizer_REST'),
                         )
             EXP_STATES = (
                              (0,'Error'),                 #RED
                              (1,'Cancelled'),             #YELLOW
                              (2,'Running'),               #GREEN
                              (3,'Scheduled'),             #BLUE
                              (4,'Unknown'),               #WHITE
                          )
             CONF_TYPES = (
                              (0, 'Active'),
                              (1, 'Historical'),
                          )
             class Profile(models.Model):
                 user = models.OneToOneField(User, on_delete=models.CASCADE)
                 theme = models.CharField(max_length=30, default='spacelab')
             @receiver(post_save, sender=User)
             def create_user_profile(sender, instance, created, **kwargs):
                 if created:
                     Profile.objects.create(user=instance)
             @receiver(post_save, sender=User)
             def save_user_profile(sender, instance, **kwargs):
                 instance.profile.save()
             class Location(models.Model):
                 name = models.CharField(max_length = 30)
                 description = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'db_location'
                 def __str__(self):
                     return u'%s' % self.name
                 def get_absolute_url(self):
                     return reverse('url_location', args=[str(self.id)])
             class DeviceType(models.Model):
                 name = models.CharField(max_length = 10, choices = DEV_TYPES, default = 'dds_rest')
                 sequence = models.PositiveSmallIntegerField(default=55)
                 description = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'db_device_types'
                 def __str__(self):
                     return u'%s' % self.get_name_display()
             class Device(models.Model):
                 device_type = models.ForeignKey('DeviceType', on_delete=models.CASCADE)
                 location = models.ForeignKey('Location', on_delete=models.CASCADE)
                 ip_address = models.GenericIPAddressField(protocol='IPv4', default='0.0.0.0')
                 port_address = models.PositiveSmallIntegerField(default=2000)
                 description = models.TextField(blank=True, null=True)
                 status = models.PositiveSmallIntegerField(default=4, choices=DEV_STATES)
                 conf_active = models.PositiveIntegerField(default=0, verbose_name='Current configuration')
                 class Meta:
                     db_table = 'db_devices'
                 def __str__(self):
                     ret = u'{} [{}]'.format(self.device_type.name.upper(), self.location.name)
                     return ret
                 @property
                 def name(self):
                     return str(self)
                 def get_status(self):
                     return self.status
                 @property
                 def status_color(self):
                     color = 'muted'
                     if self.status == 0:
                         color = "danger"
                     elif self.status == 1:
                         color = "warning"
                     elif self.status == 2:
                         color = "info"
                     elif self.status == 3:
                         color = "success"
                     return color
                 def url(self, path=None):
                     if path:
                         return 'http://{}:{}/{}/'.format(self.ip_address, self.port_address, path)
                     else:
                         return 'http://{}:{}/'.format(self.ip_address, self.port_address)
                 def get_absolute_url(self):
                     return reverse('url_device', args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_device', args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_device', args=[str(self.id)])
                 def change_ip(self, ip_address, mask, gateway, dns, **kwargs):
                     if self.device_type.name=='dds':
                         try:
                             answer = dds_api.change_ip(ip = self.ip_address,
                                                        port = self.port_address,
                                                        new_ip = ip_address,
                                                        mask = mask,
                                                        gateway = gateway)
                             if answer[0]=='1':
                                 self.message = '25|DDS - {}'.format(answer)
                                 self.ip_address = ip_address
                                 self.save()
                             else:
                                 self.message = '30|DDS - {}'.format(answer)
                                 return False
                         except Exception as e:
                             self.message = '40|{}'.format(str(e))
                             return False
                     elif self.device_type.name=='rc':
                         headers = {'content-type': "application/json",
                                    'cache-control': "no-cache"}
                         ip = [int(x) for x in ip_address.split('.')]
                         dns = [int(x) for x in dns.split('.')]
                         gateway = [int(x) for x in gateway.split('.')]
                         subnet = [int(x) for x in mask.split('.')]
                         payload = {
                             "ip": ip,
                             "dns": dns,
                             "gateway": gateway,
                             "subnet": subnet
                             }
                         req = requests.post(self.url('changeip'), data=json.dumps(payload), headers=headers)
                         try:
                             answer = req.json()
                             if answer['changeip']=='ok':
                                 self.message = '25|IP succesfully changed'
                                 self.ip_address = ip_address
                                 self.save()
                             else:
                                 self.message = '30|An error ocuur when changing IP'
                         except Exception as e:
                             self.message = '40|{}'.format(str(e))
                     else:
                         self.message = 'Not implemented'
                         return False
                     return True
             class Campaign(models.Model):
                 template = models.BooleanField(default=False)
                 name = models.CharField(max_length=60, unique=True)
                 start_date = models.DateTimeField(blank=True, null=True)
                 end_date = models.DateTimeField(blank=True, null=True)
                 tags = models.CharField(max_length=40, blank=True, null=True)
                 description = models.TextField(blank=True, null=True)
                 experiments = models.ManyToManyField('Experiment', blank=True)
                 author = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
                 class Meta:
                     db_table = 'db_campaigns'
                     ordering = ('name',)
                 def __str__(self):
                     if self.template:
                         return u'{} (template)'.format(self.name)
                     else:
                         return u'{}'.format(self.name)
                 def jsonify(self):
                     data = {}
                     ignored = ('template')
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     data['start_date'] = data['start_date'].strftime('%Y-%m-%d')
                     data['end_date'] = data['end_date'].strftime('%Y-%m-%d')
                     return data
                 def parms_to_dict(self):
                     params = Params({})
                     params.add(self.jsonify(), 'campaigns')
                     for exp in Experiment.objects.filter(campaign = self):
                         params.add(exp.jsonify(), 'experiments')
                         configurations = Configuration.objects.filter(experiment=exp, type=0)
                         for conf in configurations:
                             params.add(conf.jsonify(), 'configurations')
                             if conf.device.device_type.name=='rc':
                                 for line in conf.get_lines():
                                     params.add(line.jsonify(), 'lines')
                     return params.data
                 def dict_to_parms(self, parms, CONF_MODELS):
                     experiments = Experiment.objects.filter(campaign = self)
                     if experiments:
                         for experiment in experiments:
                             experiment.delete()
                     for id_exp in parms['experiments']['allIds']:
                         exp_parms = parms['experiments']['byId'][id_exp]
                         dum = (datetime.now() - datetime(1970, 1, 1)).total_seconds()
                         exp = Experiment(name='{}'.format(dum))
                         exp.save()
                         exp.dict_to_parms(parms, CONF_MODELS, id_exp=id_exp)
                         self.experiments.add(exp)
                     camp_parms = parms['campaigns']['byId'][parms['campaigns']['allIds'][0]]
                     self.name = '{}-{}'.format(camp_parms['name'], datetime.now().strftime('%y%m%d'))
                     self.start_date = camp_parms['start_date']
                     self.end_date = camp_parms['end_date']
                     self.tags = camp_parms['tags']
                     self.save()
                     return self
                 def get_experiments_by_radar(self, radar=None):
                     ret = []
                     if radar:
                         locations = Location.objects.filter(pk=radar)
                     else:
                         locations = set([e.location for e in self.experiments.all()])
                     for loc in locations:
                         dum = {}
                         dum['name'] = loc.name
                         dum['id'] = loc.pk
                         dum['experiments'] = [e for e in self.experiments.all() if e.location==loc]
                         ret.append(dum)
                     return ret
                 def get_absolute_url(self):
                     return reverse('url_campaign', args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_campaign', args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_campaign', args=[str(self.id)])
                 def get_absolute_url_export(self):
                     return reverse('url_export_campaign', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_campaign', args=[str(self.id)])
             class RunningExperiment(models.Model):
                 radar = models.OneToOneField('Location', on_delete=models.CASCADE)
                 running_experiment = models.ManyToManyField('Experiment', blank = True)
                 status = models.PositiveSmallIntegerField(default=0, choices=RADAR_STATES)
             class Experiment(models.Model):
                 template = models.BooleanField(default=False)
                 name = models.CharField(max_length=40, default='', unique=True)
                 location = models.ForeignKey('Location', null=True, blank=True, on_delete=models.CASCADE)
                 freq = models.FloatField(verbose_name='Operating Freq. (MHz)', validators=[MinValueValidator(1), MaxValueValidator(10000)], default=49.9200)
                 start_time = models.TimeField(default='00:00:00')
                 end_time = models.TimeField(default='23:59:59')
                 task = models.CharField(max_length=36, default='', blank=True, null=True)
                 status = models.PositiveSmallIntegerField(default=4, choices=EXP_STATES)
                 author = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
                 hash = models.CharField(default='', max_length=64, null=True, blank=True)
                 class Meta:
                     db_table = 'db_experiments'
                     ordering = ('template', 'name')
                 def __str__(self):
                     if self.template:
                         return u'%s (template)' % (self.name)
                     else:
                         return u'%s' % (self.name)
                 def jsonify(self):
                     data = {}
                     ignored = ('template')
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     data['start_time'] = data['start_time'].strftime('%H:%M:%S')
                     data['end_time'] = data['end_time'].strftime('%H:%M:%S')
                     data['location'] = self.location.name
                     data['configurations'] = ['{}'.format(conf.pk) for
                         conf in Configuration.objects.filter(experiment=self, type=0)]
                     return data
                 @property
                 def radar_system(self):
                     return self.location
                 def clone(self, **kwargs):
                     confs = Configuration.objects.filter(experiment=self, type=0)
                     self.pk = None
                     self.name = '{}_{:%y%m%d}'.format(self.name, datetime.now())
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     for conf in confs:
                         conf.clone(experiment=self, template=False)
                     return self
                 def start(self):
                     '''
                     Configure and start experiments's devices
                     ABS-CGS-DDS-RC-JARS
                     '''
                     confs = []
                     allconfs = Configuration.objects.filter(experiment=self, type = 0).order_by('-device__device_type__sequence')
                     rc_mix = [conf for conf in allconfs if conf.device.device_type.name=='rc' and conf.mix]
                     if rc_mix:
                         for conf in allconfs:
                             if conf.device.device_type.name == 'rc' and  not conf.mix:
                                 continue
                             confs.append(conf)
                     else:
                         confs = allconfs
                     try:
                         for conf in confs:
                             conf.stop_device()
                             conf.write_device()
                             conf.device.conf_active = conf.pk
                             conf.device.save()
                             conf.start_device()
                             time.sleep(1)
                     except:
                         return 0
                     return 2
                 def stop(self):
                     '''
                     Stop experiments's devices
                     DDS-JARS-RC-CGS-ABS
                     '''
                     confs = Configuration.objects.filter(experiment=self, type = 0).order_by('device__device_type__sequence')
                     confs=confs.exclude(device__device_type__name='cgs')
                     try:
                         for conf in confs:
                             conf.stop_device()
                     except:
                         return 0
                     return 1
                 def get_status(self):
                     if self.status == 3:
                         return
                     confs =  Configuration.objects.filter(experiment=self, type=0)
                     for conf in confs:
                         conf.status_device()
                     total = confs.aggregate(models.Sum('device__status'))['device__status__sum']
                     if total==2*confs.count():
                         status = 1
                     elif total == 3*confs.count():
                         status = 2
                     else:
                         status = 0
                     self.status = status
                     self.save()
                 def status_color(self):
                     color = 'muted'
                     if self.status == 0:
                         color = "danger"
                     elif self.status == 1:
                         color = "warning"
                     elif self.status == 2:
                         color = "success"
                     elif self.status == 3:
                         color = "info"
                     return color
                 def parms_to_dict(self):
                     params = Params({})
                     params.add(self.jsonify(), 'experiments')
                     configurations = Configuration.objects.filter(experiment=self, type=0)
                     for conf in configurations:
                         params.add(conf.jsonify(), 'configurations')
                         if conf.device.device_type.name=='rc':
                             for line in conf.get_lines():
                                 params.add(line.jsonify(), 'lines')
                     return params.data
                 def dict_to_parms(self, parms, CONF_MODELS, id_exp=None):
                     configurations = Configuration.objects.filter(experiment=self)
                     if id_exp is not None:
                         exp_parms = parms['experiments']['byId'][id_exp]
                     else:
                         exp_parms = parms['experiments']['byId'][parms['experiments']['allIds'][0]]
                     if configurations:
                         for configuration in configurations:
                             configuration.delete()
                     for id_conf in exp_parms['configurations']:
                         conf_parms = parms['configurations']['byId'][id_conf]
                         device = Device.objects.filter(device_type__name=conf_parms['device_type'])[0]
                         model = CONF_MODELS[conf_parms['device_type']]
                         conf = model(
                             experiment = self,
                             device = device,
                             )
                         conf.dict_to_parms(parms, id=id_conf)
                     location, created = Location.objects.get_or_create(name=exp_parms['location'])
                     self.name = '{}-{}'.format(exp_parms['name'], datetime.now().strftime('%y%m%d'))
                     self.location = location
                     self.start_time = exp_parms['start_time']
                     self.end_time = exp_parms['end_time']
                     self.save()
                     return self
                 def get_absolute_url(self):
                     return reverse('url_experiment', args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_experiment', args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_experiment', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_experiment', args=[str(self.id)])
                 def get_absolute_url_export(self):
                     return reverse('url_export_experiment', args=[str(self.id)])
                 def get_absolute_url_start(self):
                     return reverse('url_start_experiment', args=[str(self.id)])
                 def get_absolute_url_stop(self):
                     return reverse('url_stop_experiment', args=[str(self.id)])
             class Configuration(PolymorphicModel):
                 template = models.BooleanField(default=False)
                 # name = models.CharField(verbose_name="Configuration Name", max_length=40, default='')
                 device = models.ForeignKey('Device', verbose_name='Device', null=True, on_delete=models.CASCADE)
                 label = models.CharField(verbose_name="Label", max_length=40, default='', blank=True, null=True)
                 experiment = models.ForeignKey('Experiment', verbose_name='Experiment', null=True, blank=True, on_delete=models.CASCADE)
                 type = models.PositiveSmallIntegerField(default=0, choices=CONF_TYPES)
                 created_date = models.DateTimeField(auto_now_add=True)
                 programmed_date = models.DateTimeField(auto_now=True)
                 parameters = models.TextField(default='{}')
                 author = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
                 hash = models.CharField(default='', max_length=64, null=True, blank=True)
                 message = ""
                 class Meta:
                     db_table = 'db_configurations'
                     ordering = ('device__device_type__name',)
                 def __str__(self):
                     ret = u'{} '.format(self.device.device_type.name.upper())
                     if 'mix' in [f.name for f in self._meta.get_fields()]:
                         if self.mix:
                             ret = '{} MIX '.format(self.device.device_type.name.upper())
                     if 'label' in [f.name for f in self._meta.get_fields()]:
                         ret += '{}'.format(self.label)
                     if self.template:
                         ret += ' (template)'
                     return ret
                 @property
                 def name(self):
                     return str(self)
                 def jsonify(self):
                     data = {}
                     ignored = ('type', 'polymorphic_ctype', 'configuration_ptr',
                                'created_date', 'programmed_date', 'template', 'device',
                                'experiment')
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     data['device_type'] = self.device.device_type.name
                     if self.device.device_type.name == 'rc':
                         data['lines'] = ['{}'.format(line.pk) for line in self.get_lines()]
                         data['delays'] = self.get_delays()
                         data['pulses'] = self.get_pulses()
                     elif self.device.device_type.name == 'jars':
                         data['decode_type'] = DECODE_TYPE[self.decode_data][1]
                     elif self.device.device_type.name == 'dds':
                         data['frequencyA_Mhz'] = float(data['frequencyA_Mhz'])
                         data['frequencyB_Mhz'] = float(data['frequencyB_Mhz'])
                         data['phaseA'] = dds_data.phase_to_binary(data['phaseA_degrees'])
                         data['phaseB'] = dds_data.phase_to_binary(data['phaseB_degrees'])
+                    elif self.device.device_type.name == 'dds_rest':
+                        data['frequencyA_Mhz'] = float(data['frequencyA_Mhz'])
+                        data['frequencyB_Mhz'] = float(data['frequencyB_Mhz'])
+                        data['phaseA'] = dds_data.phase_to_binary(data['phaseA_degrees'])
+                        data['phaseB'] = dds_data.phase_to_binary(data['phaseB_degrees'])
+                        data['delta_frequency_Mhz'] = float(data['delta_frequency_Mhz'] or 0.00)
+                        data['update_clock_Mhz']    = float(data['update_clock_Mhz'] or 0.00)
+                        data['ramp_rate_clock_Mhz'] = float(data['ramp_rate_clock_Mhz'] or 0.0)
                     return data
                 def clone(self, **kwargs):
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     return self
                 def parms_to_dict(self):
                     params = Params({})
                     params.add(self.jsonify(), 'configurations')
                     if self.device.device_type.name=='rc':
                         for line in self.get_lines():
                             params.add(line.jsonify(), 'lines')
                     return params.data
                 def parms_to_text(self):
                     raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
                 def parms_to_binary(self):
                     raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
                 def dict_to_parms(self, parameters, id=None):
                     params = Params(parameters)
                     if id:
                         data = params.get_conf(id_conf=id)
                     else:
                         data = params.get_conf(dtype=self.device.device_type.name)
                     if data['device_type']=='rc':
                         self.clean_lines()
                         lines = data.pop('lines', None)
                         for line_id in lines:
                             pass
                     for key, value in data.items():
                         if key not in ('id', 'device_type'):
                             setattr(self, key, value)
                     self.save()
                 def export_to_file(self, format="json"):
                     content_type = ''
                     if format == 'racp':
                         content_type = 'text/plain'
                         filename = '%s_%s.%s' %(self.device.device_type.name, self.name, 'racp')
                         content = self.parms_to_text(file_format = 'racp')
                     if format == 'text':
                         content_type = 'text/plain'
                         filename = '%s_%s.%s' %(self.device.device_type.name, self.name, self.device.device_type.name)
                         content = self.parms_to_text()
                     if format == 'binary':
                         content_type = 'application/octet-stream'
                         filename = '%s_%s.bin' %(self.device.device_type.name, self.name)
                         content = self.parms_to_binary()
                     if not content_type:
                         content_type = 'application/json'
                         filename = '%s_%s.json' %(self.device.device_type.name, self.name)
                         content = json.dumps(self.parms_to_dict(), indent=2)
                     fields = {'content_type':content_type,
                               'filename':filename,
                               'content':content
                               }
                     return fields
                 def import_from_file(self, fp):
                     parms = {}
                     path, ext = os.path.splitext(fp.name)
                     if ext == '.json':
                         parms = json.load(fp)
                     if ext == '.dds':
                         lines = fp.readlines()
                         parms = dds_data.text_to_dict(lines)
                     if ext == '.racp':
                         if self.device.device_type.name == 'jars':
                             parms = RacpFile(fp).to_dict()
                             parms['filter_parms'] = json.loads(self.filter_parms)
                             return parms
                         parms = RCFile(fp).to_dict()
                     return parms
                 def status_device(self):
                     self.message = 'Function not implemented'
                     return False
                 def stop_device(self):
                     self.message = 'Function not implemented'
                     return False
                 def start_device(self):
                     self.message = 'Function not implemented'
                     return False
                 def write_device(self, parms):
                     self.message = 'Function not implemented'
                     return False
                 def read_device(self):
                     self.message = 'Function not implemented'
                     return False
                 def get_absolute_url(self):
                     return reverse('url_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_dev_conf', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_dev_conf', args=[str(self.id)])
                 def get_absolute_url_export(self):
                     return reverse('url_export_dev_conf', args=[str(self.id)])
                 def get_absolute_url_write(self):
                     return reverse('url_write_dev_conf', args=[str(self.id)])
                 def get_absolute_url_read(self):
                     return reverse('url_read_dev_conf', args=[str(self.id)])
                 def get_absolute_url_start(self):
                     return reverse('url_start_dev_conf', args=[str(self.id)])
                 def get_absolute_url_stop(self):
                     return reverse('url_stop_dev_conf', args=[str(self.id)])
                 def get_absolute_url_status(self):
                     return reverse('url_status_dev_conf', args=[str(self.id)])

apps/rc/widgets.py 0 -2

             import ast
             import json
             from itertools import chain
             from django import forms
             from django.utils.safestring import mark_safe
             from django.utils.encoding import force_text
             from django.utils.html import conditional_escape
             try:
                 basestring  # attempt to evaluate basestring
                 def isstr(s):
                     return isinstance(s, basestring)
             except NameError:
                 def isstr(s):
                     return isinstance(s, str)
             class KmUnitWidget(forms.widgets.TextInput):
                 def render(self, name, value, attrs=None,renderer=None):
                     label = name
                     if isinstance(value, (int, float)):
                         unit = int(value*attrs['km2unit'])
                     elif isstr(value):
                         units = []
                         values = [s for s in value.split(',') if s]
                         for val in values:
                             units.append('{0:.0f}'.format(float(val)*attrs['km2unit']))
                         unit = ','.join(units)
                     disabled = 'disabled' if attrs.get('disabled', False) else ''
                     name = attrs.get('name', label)
                     if attrs['id'] in ('id_delays',):
                         input_type = 'text'
                     else:
                         input_type = 'number'
                     if 'line' in attrs:
                         label += '_{0}_{1}'.format(attrs['line'].pk, name.split('|')[0])
                     html = '''<div class="col-md-12 col-no-padding">
                     <div class="col-md-5 col-no-padding"><input type="{0}" step="any" {1} class="form-control" id="id_{2}" name="{3}" value="{4}"></div>
                     <div class="col-md-1 col-no-padding">Km</div>
                     <div class="col-md-5 col-no-padding"><input type="{0}" step="any" {1} class="form-control" id="id_{2}_unit" value="{5}"></div>
                     <div class="col-md-1 col-no-padding">Units</div></div><br>'''.format(input_type, disabled, label, name, value, unit)
                     script = '''<script type="text/javascript">
                     $(document).ready(function () {{
                       km_fields.push("id_{label}");
                       unit_fields.push("id_{label}_unit");
                       $("#id_{label}").change(function() {{
                         $("#id_{label}_unit").val(str2unit($(this).val()));
                         $("#id_{label}").val(str2km($("#id_{label}_unit").val()));
                         updateWindows("#id_{label}");
                       }});
                       $("#id_{label}_unit").change(function() {{
                         $(this).val(str2int($(this).val()));
                         $("#id_{label}").val(str2km($(this).val()));
                         updateWindows("#id_{label}");
                       }});
                     }});
                     </script>'''.format(label=label)
                     if disabled:
                         return mark_safe(html)
                     else:
                         return mark_safe(html+script)
             class UnitKmWidget(forms.widgets.TextInput):
                 def render(self, name, value, attrs=None,renderer=None):
                     label = name
                     if isinstance(value, (int, float)):
                         km = value/attrs['km2unit']
                     elif isinstance(value, basestring):
                         kms = []
                         values = [s for s in value.split(',') if s]
                         for val in values:
                             kms.append('{0:.0f}'.format(float(val)/attrs['km2unit']))
                         km = ','.join(kms)
                     disabled = 'disabled' if attrs.get('disabled', False) else ''
                     name = attrs.get('name', label)
                     if 'line' in attrs:
                         label += '_{0}_{1}'.format(attrs['line'].pk, name.split('|')[0])
                     html = '''<div class="col-md-12 col-no-padding">
                     <div class="col-md-5 col-no-padding"><input type="number" step="any" {0} class="form-control" id="id_{1}_unit" name="{2}" value="{3}"></div>
                     <div class="col-md-1 col-no-padding">Units</div>
                     <div class="col-md-5 col-no-padding"><input type="number" step="any" {4} class="form-control" id="id_{5}" value="{6}"></div>
                     <div class="col-md-1 col-no-padding">Km</div></div>'''.format(disabled, label, name, value, disabled, label, km)
                     script = '''<script type="text/javascript">
                     $(document).ready(function () {{
                       km_fields.push("id_{label}");
                       unit_fields.push("id_{label}_unit");
                       $("#id_{label}").change(function() {{
                         $("#id_{label}_unit").val(str2unit($(this).val()));
                       }});
                       $("#id_{label}_unit").change(function() {{
                         $("#id_{label}").val(str2km($(this).val()));
                       }});
                     }});
                     </script>'''.format(label=label)
                     if disabled:
                         return mark_safe(html)
                     else:
                         return mark_safe(html+script)
             class KmUnitHzWidget(forms.widgets.TextInput):
                 def render(self, name, value, attrs=None,renderer=None):
                     label = name
                     unit = float(value)*attrs['km2unit']
                     if unit%10==0:
                         unit = int(unit)
                     hz = 150000*float(value)**-1
                     disabled = 'disabled' if attrs.get('disabled', False) else ''
                     name = attrs.get('name', label)
                     if 'line' in attrs:
                         label += '_{0}'.format(attrs['line'].pk)
                     html = '''<div class="col-md-12 col-no-padding">
                     <div class="col-md-3 col-no-padding"><input type="number" step="any" {0} class="form-control" id="id_{1}" name="{2}" value="{3}"></div>
                     <div class="col-md-1 col-no-padding">Km</div>
                     <div class="col-md-3 col-no-padding"><input type="number" step="any" {4} class="form-control" id="id_{1}_unit" value="{5}"></div>
                     <div class="col-md-1 col-no-padding">Units</div>
                     <div class="col-md-3 col-no-padding"><input type="number" step="any" {4} class="form-control" id="id_{1}_hz" value="{6}"></div>
                     <div class="col-md-1 col-no-padding">Hz</div>
                     </div>'''.format(disabled, label, name, value, disabled, unit, hz)
                     script = '''<script type="text/javascript">
                     $(document).ready(function () {{
                       km_fields.push("id_{label}");
                       unit_fields.push("id_{label}_unit");
                       $("#id_{label}").change(function() {{
                         $("#id_{label}_unit").val(str2unit($(this).val()));
                         $("#id_{label}").val(str2km($("#id_{label}_unit").val()));
                         $("#id_{label}_hz").val(str2hz($(this).val()));
                         updateDc();
                       }});
                       $("#id_{label}_unit").change(function() {{
                         $(this).val(Math.round(parseFloat($(this).val())/10)*10);
                         $("#id_{label}").val(str2km($(this).val()));
                         $("#id_{label}_hz").val(str2hz($("#id_{label}").val()));
                         updateDc();
                       }});
                       $("#id_{label}_hz").change(function() {{
                         $("#id_{label}").val(str2hz($(this).val()));
                         $("#id_{label}_unit").val(str2unit($("#id_{label}").val()));
                         updateDc();
                       }});
                     }});
                     </script>'''.format(label=label)
                     if disabled:
                         return mark_safe(html)
                     else:
                         return mark_safe(html+script)
             class KmUnitDcWidget(forms.widgets.TextInput):
                 def render(self, name, value, attrs=None,renderer=None):
                     label = name
                     unit = int(float(value)*attrs['km2unit'])
                     disabled = 'disabled' if attrs.get('disabled', False) else ''
                     name = attrs.get('name', label)
                     label += '_{0}'.format(attrs['line'].pk)
                     dc = float(json.loads(attrs['line'].params)['pulse_width'])*100/attrs['line'].rc_configuration.ipp
                     html = '''<div class="col-md-12 col-no-padding">
                     <div class="col-md-3 col-no-padding"><input type="number" step="any" {0} class="form-control" id="id_{1}" name="{2}" value="{3}"></div>
                     <div class="col-md-1 col-no-padding">Km</div>
                     <div class="col-md-3 col-no-padding"><input type="number" step="any" {4} class="form-control" id="id_{1}_unit" value="{5}"></div>
                     <div class="col-md-1 col-no-padding">Units</div>
                     <div class="col-md-3 col-no-padding"><input type="number" step="any" {4} class="form-control" id="id_{1}_dc" value="{6}"></div>
                     <div class="col-md-1 col-no-padding">DC[%]</div>
                     </div>'''.format(disabled, label, name, value, disabled, unit, dc)
                     script = '''<script type="text/javascript">
                     $(document).ready(function () {{
                       km_fields.push("id_{label}");
                       unit_fields.push("id_{label}_unit");
                       dc_fields.push("id_{label}");
                       $("#id_{label}").change(function() {{
                         $("#id_{label}_unit").val(str2unit($(this).val()));
                         $("#id_{label}").val(str2km($("#id_{label}_unit").val()));
                         $("#id_{label}_dc").val(str2dc($("#id_{label}").val()));
                       }});
                       $("#id_{label}_unit").change(function() {{
                         $("#id_{label}").val(str2km($(this).val()));
                         $("#id_{label}_dc").val(str2dc($("#id_{label}").val()));
                       }});
                       $("#id_{label}_dc").change(function() {{
                         $("#id_{label}").val(parseFloat($(this).val())*100/parseFloat($("#id_ipp").val()));
                         $("#id_{label}_unit").val(str2unit($("#id_{label}").val()));
                       }});
                     }});
                     </script>'''.format(label=label)
                     if disabled:
                         return mark_safe(html)
                     else:
                         return mark_safe(html+script)
             class DefaultWidget(forms.widgets.TextInput):
                 def render(self, name, value, attrs=None,renderer=None):
                     print("Default widget")
                     label = name
                     disabled = 'disabled' if attrs.get('disabled', False) else ''
                     itype = 'number' if label in ('number_of_samples', 'last_height') else 'text'
                     print(label)
                     name = attrs.get('name', label)
                     print(name)
                     if 'line' in attrs:
                         label += '_{0}_{1}'.format(attrs['line'].pk, name.split('|')[0])
                     print(label)
                     if itype=='number':
                         html = '<div class="col-md-12 col-no-padding"><div class="col-md-5 col-no-padding"><input {0} type="{1}" step="any" class="form-control" id="id_{2}" name="{3}" value="{4}"></div></div>'.format(disabled, itype, label, name, value)
                     else:
                         html = '<div class="col-md-12 col-no-padding"><div class="col-md-5 col-no-padding"><input {0} type="{1}" step="any" class="form-control" id="id_{2}" name="{3}" value="{4}"></div></div>'.format(disabled, itype, label, name, value)
                     if 'last_height' in label or 'number_of_samples' in label:
                         script = '''<script type="text/javascript">
                     $(document).ready(function () {{
                       $("#id_{label}").change(function() {{
                         updateWindows("#id_{label}");
                       }});
                     }});
                     </script>'''.format(label=label)
                     else:
                         script = ''
                     if disabled:
                         return mark_safe(html)
                     else:
                         return mark_safe(html+script)
                     return mark_safe(html)
             class HiddenWidget(forms.widgets.HiddenInput):
                 def render(self, name, value, attrs=None,renderer=None):
                     label = name
                     disabled = 'disabled' if attrs.get('disabled', False) else ''
                     name = self.attrs.get('name', label)
                     html = '<input {0} type="hidden" class="form-control" id="id_{1}" name="{2}" value="{3}">'.format(disabled, label, name, value)
                     return mark_safe(html)
             class CodesWidget(forms.widgets.Textarea):
                 def render(self, name, value, attrs=None,renderer=None):
                     label = name
                     disabled = 'disabled' if attrs.get('disabled', False) else ''
                     name = attrs.get('name', label)
                     if '[' in value:
                         value = ast.literal_eval(value)
                     if isinstance(value, list):
                         codes = '\r\n'.join(value)
                     else:
                         codes = value
                     html = '<textarea rows="5" {0} class="form-control" id="id_{1}" name="{2}" style="white-space:nowrap; overflow:scroll;">{3}</textarea>'.format(disabled, label, name, codes)
                     return mark_safe(html)
             class HCheckboxSelectMultiple(forms.CheckboxSelectMultiple):
                 def render(self, name, value, attrs=None, choices=(),renderer=None):
                     if value is None: value = []
                     has_id = attrs and 'id' in attrs
                     final_attrs = self.build_attrs(attrs, {'name': name})
                     output = [u'<br><ul>']
                     # Normalize to strings
                     str_values = set([force_text(v) for v in value])
                     for i, (option_value, option_label) in enumerate(chain(self.choices, choices)):
                         # If an ID attribute was given, add a numeric index as a suffix,
                         # so that the checkboxes don't all have the same ID attribute.
                         if has_id:
                             final_attrs = dict(final_attrs, id='%s_%s' % (attrs['id'], i))
                             label_for = u' for="%s"' % final_attrs['id']
                         else:
                             label_for = ''
                         cb = forms.CheckboxInput(final_attrs, check_test=lambda value: value in str_values)
                         option_value = force_text(option_value)
                         rendered_cb = cb.render(name, option_value)
                         option_label = conditional_escape(force_text(option_label))
                         output.append(u'<span><label%s>%s %s</label></span>' % (label_for, rendered_cb, option_label))
                     output.append(u'</div><br>')
                     return mark_safe(u'\n'.join(output))

radarsys/settings.py +6 -6

             """
             Django settings for radarsys project.
             Generated by 'django-admin startproject' using Django 1.8.6.
             For more information on this file, see
             https://docs.djangoproject.com/en/1.8/topics/settings/
             For the full list of settings and their values, see
             https://docs.djangoproject.com/en/1.8/ref/settings/
             """
             # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
             import os
             BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
             # Quick-start development settings - unsuitable for production
             # See https://docs.djangoproject.com/en/1.8/howto/deployment/checklist/
             # SECURITY WARNING: keep the secret key used in production secret!
             SECRET_KEY = 'xshb$k5fc-+j16)cvyffj&9u__0q3$l!hieh#+tbzqg)*f^km0'
             # SECURITY WARNING: don't run with debug turned on in production!
             DEBUG = True
             ALLOWED_HOSTS = ['*']
             # Application definition
             INSTALLED_APPS = [
                 'django.contrib.admin',
                 'django.contrib.auth',
                 'django.contrib.contenttypes',
                 'django.contrib.sessions',
                 'django.contrib.messages',
                 'django.contrib.staticfiles',
                 'bootstrap4',
                 'polymorphic',
                 'apps.accounts',
                 'apps.main',
                 'apps.misc',
                 'apps.rc',
                 'apps.dds',
                 'apps.jars',
                 'apps.usrp',
                 'apps.abs',
                 'apps.cgs',
                 'apps.dds_rest',
             ]
             MIDDLEWARE = [
                 'django.middleware.security.SecurityMiddleware',
                 'django.contrib.sessions.middleware.SessionMiddleware',
                 'django.middleware.common.CommonMiddleware',
                 'django.middleware.csrf.CsrfViewMiddleware',
                 'django.contrib.auth.middleware.AuthenticationMiddleware',
                 'django.contrib.messages.middleware.MessageMiddleware',
                 'django.middleware.clickjacking.XFrameOptionsMiddleware',
             ]
             ROOT_URLCONF = 'radarsys.urls'
             TEMPLATES = [
                 {
                     'BACKEND': 'django.template.backends.django.DjangoTemplates',
                     'DIRS': [os.path.join(BASE_DIR, "templates")],
                     'APP_DIRS': True,
                     'OPTIONS': {
                         'context_processors': [
                             'django.template.context_processors.debug',
                             'django.template.context_processors.request',
                             'django.contrib.auth.context_processors.auth',
                             'django.contrib.messages.context_processors.messages',
                             'apps.main.processors.radarsys_globals',
                         ],
                     },
                 },
             ]
             WSGI_APPLICATION = 'radarsys.wsgi.application'
             # Database
             # https://docs.djangoproject.com/en/1.8/ref/settings/#databases
             DATABASES = {
                 'default': {
                     'ENGINE': 'django.db.backends.sqlite3',
                     'NAME': 'radarsys.sqlite',
                 }
                 # 'default': {
                 #     'ENGINE': 'django.db.backends.postgresql_psycopg2',
                 #     'NAME': os.environ.get('DB_NAME', 'radarsys'),
                 #     'USER': os.environ.get('DB_USER', 'docker'),
                 #     'PASSWORD': os.environ.get('DB_PASSWORD', 'docker'),
                 #     'HOST': os.environ.get('POSTGRES_PORT_5432_TCP_ADDR', 'localhost'),
                 #     'PORT': os.environ.get('POSTGRES_PORT_5432_TCP_PORT', '5400'),
                 #}
             }
             # Internationalization
             # https://docs.djangoproject.com/en/1.8/topics/i18n/
             LANGUAGE_CODE = 'en-us'
             TIME_ZONE = os.environ.get('TZ', 'America/Lima')
             USE_I18N = True
             USE_L10N = True
             USE_TZ = False
             # Static files (CSS, JavaScript, Images)
             # https://docs.djangoproject.com/en/1.8/howto/static-files/
             MEDIA_URL = '/media/'
             MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
             STATIC_URL = '/static/'
             STATIC_ROOT = os.path.join(BASE_DIR, 'static')
             STATICFILES_FINDERS = (
                 'django.contrib.staticfiles.finders.FileSystemFinder',
                 'django.contrib.staticfiles.finders.AppDirectoriesFinder',
             )
             # Celery stuff
             REDIS_HOST = os.environ.get('REDIS_HOST', '127.0.0.1')
             REDIS_PORT = os.environ.get('REDIS_PORT', 6300)
             BROKER_TRANSPORT = 'redis'
-            BROKER_URL = 'redis://{}:{}/0'.format(REDIS_HOST, REDIS_PORT)
+            BROKER_URL       = 'redis://{}:{}/0'.format(REDIS_HOST, REDIS_PORT)
-            CELERY_RESULT_BACKEND = 'redis://{}:{}/0'.format(REDIS_HOST, REDIS_PORT)
+            CELERY_RESULT_BACKEND    = 'redis://{}:{}/0'.format(REDIS_HOST, REDIS_PORT)
-            CELERY_BROKER_TRANSPORT = BROKER_URL
+            CELERY_BROKER_TRANSPORT  = BROKER_URL
-            CELERY_ACCEPT_CONTENT = ['application/json']
+            CELERY_ACCEPT_CONTENT    = ['application/json']
-            CELERY_TASK_SERIALIZER = 'json'
+            CELERY_TASK_SERIALIZER   = 'json'
             CELERY_RESULT_SERIALIZER = 'json'
-            CELERY_ENABLE_UTC = False
+            CELERY_ENABLE_UTC        = False

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