radarsys Commit - r110:603e3d27e4c9 · Jicamarca Repository

Import Campaign...

Fiorella Quino -

r110:603e3d27e4c9

parent child

Context file:

r110:603e3d27e4c9

Collapse all files

apps/main/models.py +16 -1

             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from datetime import datetime
             from django.db import models
             from polymorphic import PolymorphicModel
             from django.core.urlresolvers import reverse
             CONF_STATES = (
                              (0, 'Disconnected'),
                              (1, 'Connected'),
                              (2, 'Running'),
                          )
             EXP_STATES = (
                              (0,'Error'),                 #RED
                              (1,'Configurated'),          #BLUE
                              (2,'Running'),               #GREEN
                              (3,'Waiting'),               #YELLOW
                              (4,'Not Configured'),        #WHITE
                          )
             CONF_TYPES = (
                              (0, 'Active'),
                              (1, 'Historical'),
                          )
             DEV_STATES = (
                              (0, 'No connected'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                          )
             DEV_TYPES = (
                             ('', 'Select a device type'),
                             ('rc', 'Radar Controller'),
                             ('rc_mix', 'Radar Controller (Mix)'),
                             ('dds', 'Direct Digital Synthesizer'),
                             ('jars', 'Jicamarca Radar Acquisition System'),
                             ('usrp', 'Universal Software Radio Peripheral'),
                             ('cgs', 'Clock Generator System'),
                             ('abs', 'Automatic Beam Switching'),
                         )
             DEV_PORTS = {
                             'rc'    : 2000,
                             'rc_mix': 2000,
                             'dds'   : 2000,
                             'jars'  : 2000,
                             'usrp'  : 2000,
                             'cgs'   : 8080,
                             'abs'   : 8080
                         }
             RADAR_STATES = (
                              (0, 'No connected'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                              (4, 'Scheduled'),
                          )
             # Create your models here.
             class Location(models.Model):
                 name = models.CharField(max_length = 30)
                 description = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'db_location'
                 def __unicode__(self):
                     return u'%s' % self.name
                 def get_absolute_url(self):
                     return reverse('url_device', args=[str(self.id)])
             class DeviceType(models.Model):
                 name = models.CharField(max_length = 10, choices = DEV_TYPES, default = 'rc')
                 description = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'db_device_types'
                 def __unicode__(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)
                 name = models.CharField(max_length=40, default='')
                 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=0, choices=DEV_STATES)
                 class Meta:
                     db_table = 'db_devices'
                 def __unicode__(self):
                     return u'%s | %s' % (self.name, self.ip_address)
                 def get_status(self):
                     return self.status
                 def get_absolute_url(self):
                     return reverse('url_device', args=[str(self.id)])
             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)
                 description = models.TextField(blank=True, null=True)
                 experiments = models.ManyToManyField('Experiment', blank=True)
                 class Meta:
                     db_table = 'db_campaigns'
                     ordering = ('name',)
                 def __unicode__(self):
                     return u'%s' % (self.name)
                 def get_absolute_url(self):
                     return reverse('url_campaign', args=[str(self.id)])
                 def parms_to_dict(self):
                     import json
                     parameters = {}
                     exp_parameters = {}
                     experiments = Experiment.objects.filter(campaign = self)
                     i=1
                     for experiment in experiments:
                         exp_parameters['experiment-'+str(i)]  = json.loads(experiment.parms_to_dict())
                         i += 1
                     parameters['experiments'] = exp_parameters
                     parameters['end_date']    = self.end_date.strftime("%Y-%m-%d")
                     parameters['start_date']  = self.start_date.strftime("%Y-%m-%d")
                     parameters['campaign']    = self.__unicode__()
                     parameters['tags']        =self.tags
                     parameters = json.dumps(parameters, indent=2, sort_keys=False)
                     return parameters
                 def import_from_file(self, fp):
                     import os, json
                     parms = {}
                     path, ext = os.path.splitext(fp.name)
                     if ext == '.json':
                         parms = json.load(fp)
                     return parms
                 def dict_to_parms(self, parms, CONF_MODELS):
                     experiments = Experiment.objects.filter(campaign = self)
                     configurations = Configuration.objects.filter(experiment = experiments)
                     if configurations:
                         for configuration in configurations:
                             configuration.delete()
                     if experiments:
                         for experiment in experiments:
                             experiment.delete()
                     for parms_exp in parms['experiments']:
                         location = Location.objects.get(name = parms['experiments'][parms_exp]['radar'])
                         new_exp = Experiment(
                                              name        = parms['experiments'][parms_exp]['experiment'],
                                              location    = location,
                                              start_time  = parms['experiments'][parms_exp]['start_time'],
                                              end_time    = parms['experiments'][parms_exp]['end_time'],
                                              )
                         new_exp.save()
                         new_exp.dict_to_parms(parms['experiments'][parms_exp],CONF_MODELS)
                         new_exp.save()
+                        self.name       = parms['campaign']
+                        self.start_date = parms['start_date']
+                        self.end_date   = parms['end_date']
+                        self.tags       = parms['tags']
                         self.experiments.add(new_exp)
                         self.save()
+                    return self
                 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_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)
                 start_time = models.TimeField(default='00:00:00')
                 end_time = models.TimeField(default='23:59:59')
                 status = models.PositiveSmallIntegerField(default=0, choices=EXP_STATES)
                 class Meta:
                     db_table = 'db_experiments'
                     ordering = ('template', 'name')
                 def __unicode__(self):
                     if self.template:
                         return u'%s (template)' % (self.name)
                     else:
                         return u'%s' % (self.name)
                 @property
                 def radar(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 get_status(self):
                     configurations =  Configuration.objects.filter(experiment=self)
                     exp_status=[]
                     for conf in configurations:
                         print conf.status_device()
                         exp_status.append(conf.status_device())
                     if not exp_status: #No Configuration
                         self.status = 4
                         self.save()
                         return
                     total = 1
                     for e_s in exp_status:
                         total = total*e_s
                     if total == 0:                      #Error
                         status = 0
                     elif total == (3**len(exp_status)): #Running
                         status = 2
                     else:
                         status = 1                      #Configurated
                     self.status = status
                     self.save()
                 def status_color(self):
                     color = 'danger'
                     if self.status == 0:
                         color = "danger"
                     elif self.status == 1:
                         color = "info"
                     elif self.status == 2:
                         color = "success"
                     elif self.status == 3:
                         color = "warning"
                     else:
                         color = "muted"
                     return color
                 def get_absolute_url(self):
                     return reverse('url_experiment', args=[str(self.id)])
                 def parms_to_dict(self):
                     import json
                     configurations = Configuration.objects.filter(experiment=self)
                     conf_parameters = {}
                     parameters={}
                     for configuration in configurations:
                         if 'cgs' in configuration.device.device_type.name:
                             conf_parameters['cgs'] = configuration.parms_to_dict()
                         if 'dds' in configuration.device.device_type.name:
                             conf_parameters['dds'] = configuration.parms_to_dict()
                         if 'rc' in configuration.device.device_type.name:
                             conf_parameters['rc'] = configuration.parms_to_dict()
                         if 'jars' in configuration.device.device_type.name:
                             conf_parameters['jars'] = configuration.parms_to_dict()
                         if 'usrp' in configuration.device.device_type.name:
                             conf_parameters['usrp'] = configuration.parms_to_dict()
                         if 'abs' in configuration.device.device_type.name:
                             conf_parameters['abs'] = configuration.parms_to_dict()
                     parameters['configurations'] = conf_parameters
                     parameters['end_time']       = self.end_time.strftime("%H:%M:%S")
                     parameters['start_time']     = self.start_time.strftime("%H:%M:%S")
                     parameters['radar']          = self.radar.name
                     parameters['experiment']     = self.name
                     parameters = json.dumps(parameters, indent=2)
                     return parameters
                 def import_from_file(self, fp):
                     import os, json
                     parms = {}
                     path, ext = os.path.splitext(fp.name)
                     if ext == '.json':
                         parms = json.load(fp)
                     return parms
                 def dict_to_parms(self, parms, CONF_MODELS):
                     configurations = Configuration.objects.filter(experiment=self)
                     if configurations:
                                 for configuration in configurations:
                                     configuration.delete()
                     for conf_type in parms['configurations']:
                                 #--For ABS Device:
                                 #--For USRP Device:
                                 #--For JARS Device:
                                 #--For RC Device:
                                 if conf_type == 'rc':
                                     device = get_object_or_404(Device, pk=parms['configurations']['rc']['device_id'])
                                     DevConfModel = CONF_MODELS[conf_type]
                                     confrc_form = DevConfModel(
                                                               experiment = self,
                                                               name = 'RC',
                                                               device=device,
                                                               )
                                     confrc_form.dict_to_parms(parms['configurations']['rc'])
                                     confrc_form.save()
                                 #--For DDS Device:
                                 if conf_type == 'dds':
                                     device = get_object_or_404(Device, pk=parms['configurations']['dds']['device_id'])
                                     DevConfModel = CONF_MODELS[conf_type]
                                     confdds_form = DevConfModel(
                                                               experiment = self,
                                                               name = 'DDS',
                                                               device=device,
                                                               )
                                     confdds_form.dict_to_parms(parms['configurations']['dds'])
                                     confdds_form.save()
                                 #--For CGS Device:
                                 if conf_type == 'cgs':
                                     device = get_object_or_404(Device, pk=parms['configurations']['cgs']['device_id'])
                                     DevConfModel = CONF_MODELS[conf_type]
                                     confcgs_form = DevConfModel(
                                                               experiment = self,
                                                               name = 'CGS',
                                                               device=device,
                                                               )
                                     confcgs_form.dict_to_parms(parms['configurations']['cgs'])
                                     confcgs_form.save()
+                    location = Location.objects.get(name = parms['radar'])
+                    self.name       = parms['experiment']
+                    self.location   = location
+                    self.start_time = parms['start_time']
+                    self.end_time   = parms['end_time']
+                    self.save()
+                    return self
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_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)])
             class Configuration(PolymorphicModel):
                 template = models.BooleanField(default=False)
                 name = models.CharField(verbose_name="Configuration Name", max_length=40, default='')
                 experiment = models.ForeignKey('Experiment', null=True, blank=True, on_delete=models.CASCADE)
                 device = models.ForeignKey(Device, null=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='{}')
                 message = ""
                 class Meta:
                     db_table = 'db_configurations'
                 def __unicode__(self):
                     return u'[%s]: %s' % (self.device.name, self.name)
                 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):
                     parameters = {}
                     for key in self.__dict__.keys():
                         parameters[key] = getattr(self, key)
                     return parameters
                 def parms_to_text(self):
                     raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
                     return ''
                 def parms_to_binary(self):
                     raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
                     return ''
                 def dict_to_parms(self, parameters):
                     if type(parameters) != type({}):
                         return
                     for key in parameters.keys():
                         setattr(self, key, parameters[key])
                 def export_to_file(self, format="json"):
                     import json
                     content_type = ''
                     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):
                     import os, json
                     parms = {}
                     path, ext = os.path.splitext(fp.name)
                     if ext == '.json':
                         parms = json.load(fp)
                     return parms
                 def status_device(self):
                     raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
                     return None
                 def stop_device(self):
                     raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
                     return None
                 def start_device(self):
                     raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
                     return None
                 def write_device(self, parms):
                     raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
                     return None
                 def read_device(self):
                     raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
                     return None
                 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_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/main/views.py +5 -35

             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.utils.safestring import mark_safe
             from django.http import HttpResponseRedirect
             from django.core.urlresolvers import reverse
             from django.contrib import messages
             from datetime import datetime
             from .forms import CampaignForm, ExperimentForm, DeviceForm, ConfigurationForm, LocationForm, UploadFileForm, DownloadFileForm, OperationForm, NewForm
             from .forms import OperationSearchForm
             from apps.cgs.forms import CGSConfigurationForm
             from apps.jars.forms import JARSConfigurationForm
             from apps.usrp.forms import USRPConfigurationForm
             from apps.abs.forms import ABSConfigurationForm
             from apps.rc.forms import RCConfigurationForm, RCMixConfigurationForm
             from apps.dds.forms import DDSConfigurationForm
             from .models import Campaign, Experiment, Device, Configuration, Location, RunningExperiment
             from apps.cgs.models import CGSConfiguration
             from apps.jars.models import JARSConfiguration
             from apps.usrp.models import USRPConfiguration
             from apps.abs.models import ABSConfiguration
             from apps.rc.models import RCConfiguration, RCLine, RCLineType
             from apps.dds.models import DDSConfiguration
             # Create your views here.
             CONF_FORMS = {
                 'rc': RCConfigurationForm,
                 'rc_mix': RCMixConfigurationForm,
                 'dds': DDSConfigurationForm,
                 'jars': JARSConfigurationForm,
                 'cgs': CGSConfigurationForm,
                 'abs': ABSConfigurationForm,
                 'usrp': USRPConfigurationForm,
             }
             CONF_MODELS = {
                 'rc': RCConfiguration,
                 'dds': DDSConfiguration,
                 'jars': JARSConfiguration,
                 'cgs': CGSConfiguration,
                 'abs': ABSConfiguration,
                 'usrp': USRPConfiguration,
             }
             MIX_MODES = {
                 '0': 'OR',
                 '1': 'XOR',
                 '2': 'AND',
                 '3': 'NAND'
             }
             def index(request):
                 kwargs = {}
                 return render(request, 'index.html', kwargs)
             def locations(request):
                 locations = Location.objects.all().order_by('name')
                 keys = ['id', 'name', 'description']
                 kwargs = {}
                 kwargs['location_keys'] = keys[1:]
                 kwargs['locations'] = locations
                 kwargs['title'] = 'Location'
                 kwargs['suptitle'] = 'List'
                 kwargs['button'] = 'New Location'
                 return render(request, 'locations.html', kwargs)
             def location(request, id_loc):
                 location = get_object_or_404(Location, pk=id_loc)
                 kwargs = {}
                 kwargs['location'] = location
                 kwargs['location_keys'] = ['name', 'description']
                 kwargs['title'] = 'Location'
                 kwargs['suptitle'] = 'Details'
                 return render(request, 'location.html', kwargs)
             def location_new(request):
                 if request.method == 'GET':
                     form = LocationForm()
                 if request.method == 'POST':
                     form = LocationForm(request.POST)
                     if form.is_valid():
                         form.save()
                         return redirect('url_locations')
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Location'
                 kwargs['suptitle'] = 'New'
                 kwargs['button'] = 'Create'
                 return render(request, 'location_edit.html', kwargs)
             def location_edit(request, id_loc):
                 location = get_object_or_404(Location, pk=id_loc)
                 if request.method=='GET':
                     form = LocationForm(instance=location)
                 if request.method=='POST':
                     form = LocationForm(request.POST, instance=location)
                     if form.is_valid():
                         form.save()
                         return redirect('url_locations')
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Location'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'location_edit.html', kwargs)
             def location_delete(request, id_loc):
                 location = get_object_or_404(Location, pk=id_loc)
                 if request.method=='POST':
                     if request.user.is_staff:
                         location.delete()
                         return redirect('url_locations')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(location.get_absolute_url())
                 kwargs = {
                           'title': 'Delete',
                           'suptitle': 'Location',
                           'object': location,
                           'previous': location.get_absolute_url(),
                           'delete': True
                           }
                 return render(request, 'confirm.html', kwargs)
             def devices(request):
                 devices = Device.objects.all().order_by('device_type__name')
             #     keys = ['id', 'device_type__name', 'name', 'ip_address']
                 keys = ['id', 'name', 'ip_address', 'port_address', 'device_type']
                 kwargs = {}
                 kwargs['device_keys'] = keys[1:]
                 kwargs['devices'] = devices#.values(*keys)
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'List'
                 kwargs['button'] = 'New Device'
                 return render(request, 'devices.html', kwargs)
             def device(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 kwargs = {}
                 kwargs['device'] = device
                 kwargs['device_keys'] = ['device_type', 'name', 'ip_address', 'port_address', 'description']
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'Details'
                 return render(request, 'device.html', kwargs)
             def device_new(request):
                 if request.method == 'GET':
                     form = DeviceForm()
                 if request.method == 'POST':
                     form = DeviceForm(request.POST)
                     if form.is_valid():
                         form.save()
                         return redirect('url_devices')
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'New'
                 kwargs['button'] = 'Create'
                 return render(request, 'device_edit.html', kwargs)
             def device_edit(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 if request.method=='GET':
                     form = DeviceForm(instance=device)
                 if request.method=='POST':
                     form = DeviceForm(request.POST, instance=device)
                     if form.is_valid():
                         form.save()
                         return redirect(device.get_absolute_url())
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'device_edit.html', kwargs)
             def device_delete(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 if request.method=='POST':
                     if request.user.is_staff:
                         device.delete()
                         return redirect('url_devices')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(device.get_absolute_url())
                 kwargs = {
                           'title': 'Delete',
                           'suptitle': 'Device',
                           'object': device,
                           'previous': device.get_absolute_url(),
                           'delete': True
                           }
                 return render(request, 'confirm.html', kwargs)
             def campaigns(request):
                 campaigns = Campaign.objects.all().order_by('start_date')
                 keys = ['id', 'name', 'start_date', 'end_date']
                 kwargs = {}
                 kwargs['campaign_keys'] = keys[1:]
                 kwargs['campaigns'] = campaigns#.values(*keys)
                 kwargs['title'] = 'Campaign'
                 kwargs['suptitle'] = 'List'
                 kwargs['button'] = 'New Campaign'
                 return render(request, 'campaigns.html', kwargs)
             def campaign(request, id_camp):
                 campaign = get_object_or_404(Campaign, pk=id_camp)
                 experiments = Experiment.objects.filter(campaign=campaign)
                 form = CampaignForm(instance=campaign)
                 kwargs = {}
                 kwargs['campaign'] = campaign
                 kwargs['campaign_keys'] = ['template', 'name', 'start_date', 'end_date', 'tags', 'description']
                 kwargs['experiments'] = experiments
                 kwargs['experiment_keys'] = ['name', 'radar', 'start_time', 'end_time']
                 kwargs['title'] = 'Campaign'
                 kwargs['suptitle'] = 'Details'
                 kwargs['form'] = form
                 kwargs['button'] = 'Add Experiment'
                 return render(request, 'campaign.html', kwargs)
             def campaign_new(request):
                 kwargs = {}
                 if request.method == 'GET':
                     if 'template' in request.GET:
                         if request.GET['template']=='0':
                             form = NewForm(initial={'create_from':2},
                                            template_choices=Campaign.objects.filter(template=True).values_list('id', 'name'))
                         else:
                             kwargs['button'] = 'Create'
                             kwargs['experiments'] = Configuration.objects.filter(experiment=request.GET['template'])
                             kwargs['experiment_keys'] = ['name', 'start_time', 'end_time']
                             camp = Campaign.objects.get(pk=request.GET['template'])
                             form = CampaignForm(instance=camp,
                                                 initial={'name':'{} [{:%Y/%m/%d}]'.format(camp.name, datetime.now()),
                                                          'template':False})
                     elif 'blank' in request.GET:
                         kwargs['button'] = 'Create'
                         form = CampaignForm()
                     else:
                         form = NewForm()
                 if request.method == 'POST':
                     kwargs['button'] = 'Create'
                     post = request.POST.copy()
                     experiments = []
                     for id_exp in post.getlist('experiments'):
                         exp = Experiment.objects.get(pk=id_exp)
                         new_exp = exp.clone(template=False)
                         experiments.append(new_exp)
                     post.setlist('experiments', [])
                     form = CampaignForm(post)
                     if form.is_valid():
                         campaign = form.save()
                         for exp in experiments:
                             campaign.experiments.add(exp)
                         campaign.save()
                         return redirect('url_campaign', id_camp=campaign.id)
                 kwargs['form'] = form
                 kwargs['title'] = 'Campaign'
                 kwargs['suptitle'] = 'New'
                 return render(request, 'campaign_edit.html', kwargs)
             def campaign_edit(request, id_camp):
                 campaign = get_object_or_404(Campaign, pk=id_camp)
                 if request.method=='GET':
                     form = CampaignForm(instance=campaign)
                 if request.method=='POST':
                     exps = campaign.experiments.all().values_list('pk', flat=True)
                     post = request.POST.copy()
                     new_exps = post.getlist('experiments')
                     post.setlist('experiments', [])
                     form = CampaignForm(post, instance=campaign)
                     if form.is_valid():
                         camp = form.save()
                         for id_exp in new_exps:
                             if int(id_exp) in exps:
                                 exps.pop(id_exp)
                             else:
                                 exp = Experiment.objects.get(pk=id_exp)
                                 if exp.template:
                                     camp.experiments.add(exp.clone(template=False))
                                 else:
                                     camp.experiments.add(exp)
                         for id_exp in exps:
                             camp.experiments.remove(Experiment.objects.get(pk=id_exp))
                         return redirect('url_campaign', id_camp=id_camp)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Campaign'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'campaign_edit.html', kwargs)
             def campaign_delete(request, id_camp):
                 campaign = get_object_or_404(Campaign, pk=id_camp)
                 if request.method=='POST':
                     if request.user.is_staff:
                         for exp in campaign.experiments.all():
                             for conf in Configuration.objects.filter(experiment=exp):
                                 conf.delete()
                             exp.delete()
                         campaign.delete()
                         return redirect('url_campaigns')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(campaign.get_absolute_url())
                 kwargs = {
                           'title': 'Delete',
                           'suptitle': 'Campaign',
                           'object': campaign,
                           'previous': campaign.get_absolute_url(),
                           'delete': True
                           }
                 return render(request, 'confirm.html', kwargs)
             def campaign_export(request, id_camp):
                 campaign = get_object_or_404(Campaign, pk=id_camp)
                 content = campaign.parms_to_dict()
                 content_type = 'application/json'
                 filename     =  '%s_%s.json' %(campaign.name, campaign.id)
                 response = HttpResponse(content_type=content_type)
                 response['Content-Disposition'] = 'attachment; filename="%s"' %filename
                 response.write(content)
                 return response
             def campaign_import(request, id_camp):
                 campaign = get_object_or_404(Campaign, pk=id_camp)
                 if request.method == 'GET':
                     file_form = UploadFileForm()
                 if request.method == 'POST':
                     file_form = UploadFileForm(request.POST, request.FILES)
                     if file_form.is_valid():
                         parms = campaign.import_from_file(request.FILES['file'])
                         if parms:
                             parms['name'] = parms['campaign']
-                            campaign.dict_to_parms(parms, CONF_MODELS)
+                            new_camp = campaign.dict_to_parms(parms, CONF_MODELS)
                             messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name)
-                            form = CampaignForm(initial=parms, instance=campaign)
+                            return redirect(new_camp.get_absolute_url_edit())
-                            kwargs = {}
-                            kwargs['form'] = form
-                            kwargs['title'] = 'Campaign'
-                            kwargs['suptitle'] = 'Parameters imported'
-                            kwargs['button'] = 'Save'
-                            kwargs['action'] = campaign.get_absolute_url_edit()
-                            kwargs['previous'] = campaign.get_absolute_url()
-                            return render(request, 'campaign_edit.html', kwargs)
                     messages.error(request, "Could not import parameters from file")
                 kwargs = {}
                 kwargs['title'] = 'Campaign'
                 kwargs['form'] = file_form
                 kwargs['suptitle'] = 'Importing file'
                 kwargs['button'] = 'Import'
                 return render(request, 'campaign_import.html', kwargs)
             def experiments(request):
                 experiment_list = Experiment.objects.all()
                 keys = ['id', 'name', 'start_time', 'end_time']
                 kwargs = {}
                 kwargs['experiment_keys'] = keys[1:]
                 kwargs['experiments'] = experiment_list
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'List'
                 kwargs['button'] = 'New Experiment'
                 return render(request, 'experiments.html', kwargs)
             def experiment(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 configurations = Configuration.objects.filter(experiment=experiment, type=0)
                 kwargs = {}
                 kwargs['experiment_keys'] = ['template', 'radar', 'name', 'start_time', 'end_time']
                 kwargs['experiment'] = experiment
                 kwargs['configuration_keys'] = ['name', 'device__device_type', 'device__ip_address', 'device__port_address']
                 kwargs['configurations'] = configurations
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Add Configuration'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment.html', kwargs)
             def experiment_new(request, id_camp=None):
                 kwargs = {}
                 if request.method == 'GET':
                     if 'template' in request.GET:
                         if request.GET['template']=='0':
                             form = NewForm(initial={'create_from':2},
                                            template_choices=Experiment.objects.filter(template=True).values_list('id', 'name'))
                         else:
                             kwargs['button'] = 'Create'
                             kwargs['configurations'] = Configuration.objects.filter(experiment=request.GET['template'])
                             kwargs['configuration_keys'] = ['name', 'device__name', 'device__ip_address', 'device__port_address']
                             exp=Experiment.objects.get(pk=request.GET['template'])
                             form = ExperimentForm(instance=exp,
                                                   initial={'name': '{} [{:%Y/%m/%d}]'.format(exp.name, datetime.now()),
                                                            'template': False})
                     elif 'blank' in request.GET:
                         kwargs['button'] = 'Create'
                         form = ExperimentForm()
                     else:
                         form = NewForm()
                 if request.method == 'POST':
                     form = ExperimentForm(request.POST)
                     if form.is_valid():
                         experiment = form.save()
                         if 'template' in request.GET:
                             configurations = Configuration.objects.filter(experiment=request.GET['template'], type=0)
                             for conf in configurations:
                                 conf.clone(experiment=experiment, template=False)
                         return redirect('url_experiment', id_exp=experiment.id)
                 kwargs['form'] = form
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'New'
                 return render(request, 'experiment_edit.html', kwargs)
             def experiment_edit(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 if request.method == 'GET':
                     form = ExperimentForm(instance=experiment)
                 if request.method=='POST':
                     form = ExperimentForm(request.POST, instance=experiment)
                     if form.is_valid():
                         experiment = form.save()
                         return redirect('url_experiment', id_exp=experiment.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'experiment_edit.html', kwargs)
             def experiment_delete(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 if request.method=='POST':
                     if request.user.is_staff:
                         for conf in Configuration.objects.filter(experiment=experiment):
                             conf.delete()
                         experiment.delete()
                         return redirect('url_experiments')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(experiment.get_absolute_url())
                 kwargs = {
                           'title': 'Delete',
                           'suptitle': 'Experiment',
                           'object': experiment,
                           'previous': experiment.get_absolute_url(),
                           'delete': True
                           }
                 return render(request, 'confirm.html', kwargs)
             def experiment_export(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 content = experiment.parms_to_dict()
                 content_type = 'application/json'
                 filename     =  '%s_%s.json' %(experiment.name, experiment.id)
                 response = HttpResponse(content_type=content_type)
                 response['Content-Disposition'] = 'attachment; filename="%s"' %filename
                 response.write(content)
                 return response
             def experiment_import(request, id_exp):
                 experiment     = get_object_or_404(Experiment, pk=id_exp)
                 configurations = Configuration.objects.filter(experiment=experiment)
                 if request.method == 'GET':
                     file_form = UploadFileForm()
                 if request.method == 'POST':
                     file_form = UploadFileForm(request.POST, request.FILES)
                     if file_form.is_valid():
                         parms = experiment.import_from_file(request.FILES['file'])
                         if parms:
-                            location = Location.objects.get(name = parms['radar'])
-                            parms['location'] = location.id
-                            parms['name']     = parms['experiment']
-                            experiment.dict_to_parms(parms, CONF_MODELS)
+                            new_exp = experiment.dict_to_parms(parms, CONF_MODELS)
                             messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name)
-                            form = ExperimentForm(initial=parms, instance=experiment)
+                            return redirect(new_exp.get_absolute_url_edit())
-                            kwargs = {}
-                            #kwargs['id_dev'] = conf.id
-                            kwargs['form'] = form
-                            kwargs['title'] = 'Experiment'
-                            kwargs['suptitle'] = 'Parameters imported'
-                            kwargs['button'] = 'Save'
-                            kwargs['action'] = experiment.get_absolute_url_edit()
-                            kwargs['previous'] = experiment.get_absolute_url()
-                            ###### SIDEBAR ######
-                            #kwargs.update(sidebar(conf=conf))
-                            kwargs.update(sidebar(experiment=experiment))
-                            return render(request, 'experiment_edit.html', kwargs)
                     messages.error(request, "Could not import parameters from file")
                 kwargs = {}
-                #kwargs['id_dev'] = conf.id
                 kwargs['title'] = 'Experiment'
                 kwargs['form'] = file_form
                 kwargs['suptitle'] = 'Importing file'
                 kwargs['button'] = 'Import'
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment_import.html', kwargs)
             def experiment_mix(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 rc_confs = [conf for conf in RCConfiguration.objects.filter(experiment=id_exp,
                                                                             mix=False)]
                 if len(rc_confs)<2:
                     messages.warning(request, 'You need at least two RC Configurations to make a mix')
                     return redirect(experiment.get_absolute_url())
                 mix_confs = RCConfiguration.objects.filter(experiment=id_exp, mix=True)
                 if mix_confs:
                     mix = mix_confs[0]
                 else:
                     mix = RCConfiguration(experiment=experiment,
                                           device=rc_confs[0].device,
                                           ipp=rc_confs[0].ipp,
                                           clock_in=rc_confs[0].clock_in,
                                           clock_divider=rc_confs[0].clock_divider,
                                           mix=True,
                                           parameters='')
                     mix.save()
                     line_type = RCLineType.objects.get(name='mix')
                     for i in range(len(rc_confs[0].get_lines())):
                         line = RCLine(rc_configuration=mix, line_type=line_type, channel=i)
                         line.save()
                 initial = {'name': mix.name,
                            'result': parse_mix_result(mix.parameters),
                            'delay': 0,
                            'mask': [0,1,2,3,4,5,6,7]
                            }
                 if request.method=='GET':
                     form = RCMixConfigurationForm(confs=rc_confs, initial=initial)
                 if request.method=='POST':
                     result = mix.parameters
                     if '{}|'.format(request.POST['experiment']) in result:
                         messages.error(request, 'Configuration already added')
                     else:
                         if result:
                             result = '{}-{}|{}|{}|{}'.format(mix.parameters,
                                                           request.POST['experiment'],
                                                           MIX_MODES[request.POST['operation']],
                                                           float(request.POST['delay']),
                                                           parse_mask(request.POST.getlist('mask'))
                                                           )
                         else:
                             result = '{}|{}|{}|{}'.format(request.POST['experiment'],
                                                        MIX_MODES[request.POST['operation']],
                                                        float(request.POST['delay']),
                                                        parse_mask(request.POST.getlist('mask'))
                                                        )
                         mix.parameters = result
                         mix.name = request.POST['name']
                         mix.save()
                         mix.update_pulses()
                     initial['result'] = parse_mix_result(result)
                     initial['name'] = mix.name
                     form = RCMixConfigurationForm(initial=initial, confs=rc_confs)
                 kwargs = {
                           'title': 'Experiment',
                           'suptitle': 'Mix Configurations',
                           'form' : form,
                           'extra_button': 'Delete',
                           'button': 'Add',
                           'cancel': 'Back',
                           'previous': experiment.get_absolute_url(),
                           'id_exp':id_exp,
                           }
                 return render(request, 'experiment_mix.html', kwargs)
             def experiment_mix_delete(request, id_exp):
                 conf = RCConfiguration.objects.get(experiment=id_exp, mix=True)
                 values = conf.parameters.split('-')
                 conf.parameters = '-'.join(values[:-1])
                 conf.save()
                 return redirect('url_mix_experiment', id_exp=id_exp)
             def parse_mix_result(s):
                 values = s.split('-')
                 html = ''
                 for i, value in enumerate(values):
                     if not value:
                         continue
                     pk, mode, delay, mask = value.split('|')
                     conf = RCConfiguration.objects.get(pk=pk)
                     if i==0:
                         html += '{:20.18}{:4}{:9}km{:>6}\r\n'.format(
                                             conf.name[:18],
                                             '---',
                                             delay,
                                             mask)
                     else:
                         html += '{:20.18}{:4}{:9}km{:>6}\r\n'.format(
                                             conf.name[:18],
                                             mode,
                                             delay,
                                             mask)
                 return mark_safe(html)
             def parse_mask(l):
                 values = []
                 for x in range(8):
                     if '{}'.format(x) in l:
                         values.append(1)
                     else:
                         values.append(0)
                 values.reverse()
                 return int(''.join([str(x) for x in values]), 2)
             def dev_confs(request):
                 configurations = Configuration.objects.all().order_by('type', 'device__device_type', 'experiment')
                 kwargs = {}
                 kwargs['configuration_keys'] = ['device', 'name', 'experiment', 'type', 'programmed_date']
                 kwargs['configurations'] = configurations
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'List'
                 return render(request, 'dev_confs.html', kwargs)
             def dev_conf(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 return redirect(conf.get_absolute_url())
             def dev_conf_new(request, id_exp=0, id_dev=0):
                 initial = {}
                 kwargs = {}
                 if id_exp<>0:
                     initial['experiment'] = id_exp
                 if id_dev<>0:
                     initial['device'] = id_dev
                 if request.method == 'GET':
                     if id_dev:
                         kwargs['button'] = 'Create'
                         device = Device.objects.get(pk=id_dev)
                         DevConfForm = CONF_FORMS[device.device_type.name]
                         initial['name'] = request.GET['name']
                         form = DevConfForm(initial=initial)
                     else:
                         if 'template' in request.GET:
                             if request.GET['template']=='0':
                                 form = NewForm(initial={'create_from':2},
                                                template_choices=Configuration.objects.filter(template=True).values_list('id', 'name'))
                             else:
                                 kwargs['button'] = 'Create'
                                 conf = Configuration.objects.get(pk=request.GET['template'])
                                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                                 form = DevConfForm(instance=conf,
                                                    initial={'name': '{} [{:%Y/%m/%d}]'.format(conf.name, datetime.now()),
                                                             'template': False})
                         elif 'blank' in request.GET:
                             kwargs['button'] = 'Create'
                             form = ConfigurationForm(initial=initial)
                         else:
                             form = NewForm()
                 if request.method == 'POST':
                     device = Device.objects.get(pk=request.POST['device'])
                     DevConfForm = CONF_FORMS[device.device_type.name]
                     form = DevConfForm(request.POST)
                     if form.is_valid():
                         conf = form.save()
                         if 'template' in request.GET and conf.device.device_type.name=='rc':
                             lines = RCLine.objects.filter(rc_configuration=request.GET['template'])
                             for line in lines:
                                 line.clone(rc_configuration=conf)
                         return redirect('url_dev_conf', id_conf=conf.pk)
                 kwargs['id_exp'] = id_exp
                 kwargs['form'] = form
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'New'
                 if id_dev != 0:
                     device = Device.objects.get(pk=id_dev)
                     if 'dds' in device.device_type.name:
                         kwargs['dds_device'] = True
                 return render(request, 'dev_conf_edit.html', kwargs)
             def dev_conf_edit(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 dev_conf = DevConfModel.objects.get(pk=id_conf)
                 if request.method=='GET':
                     form = DevConfForm(instance=dev_conf)
                 if request.method=='POST':
                     form = DevConfForm(request.POST, instance=dev_conf)
                     if form.is_valid():
                         form.save()
                         return redirect('url_dev_conf', id_conf=id_conf)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
             def dev_conf_start(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 conf = DevConfModel.objects.get(pk=id_conf)
                 if conf.start_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 conf.status_device()
                 return redirect(conf.get_absolute_url())
             def dev_conf_stop(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 conf = DevConfModel.objects.get(pk=id_conf)
                 if conf.stop_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 conf.status_device()
                 return redirect(conf.get_absolute_url())
             def dev_conf_status(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 conf = DevConfModel.objects.get(pk=id_conf)
                 if conf.status_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 return redirect(conf.get_absolute_url())
             def dev_conf_write(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 conf = DevConfModel.objects.get(pk=id_conf)
                 answer = conf.write_device()
                 conf.status_device()
                 if answer:
                     messages.success(request, conf.message)
                     #Creating a historical configuration
                     conf.clone(type=0, template=False)
                     #Original configuration
                     conf = DevConfModel.objects.get(pk=id_conf)
                 else:
                     messages.error(request, conf.message)
                 return redirect(conf.get_absolute_url())
             def dev_conf_read(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 conf = DevConfModel.objects.get(pk=id_conf)
                 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 = DevConfForm(initial=parms, instance=conf)
                 if request.method=='POST':
                     form = DevConfForm(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['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Parameters read from device'
                 kwargs['button'] = 'Save'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, '%s_conf_edit.html' %conf.device.device_type.name, kwargs)
             def dev_conf_import(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 conf = DevConfModel.objects.get(pk=id_conf)
                 if request.method == 'GET':
                     file_form = UploadFileForm()
                 if request.method == 'POST':
                     file_form = UploadFileForm(request.POST, request.FILES)
                     if file_form.is_valid():
                         parms = conf.import_from_file(request.FILES['file'])
                         if parms:
                             messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name)
                             form = DevConfForm(initial=parms, instance=conf)
                             kwargs = {}
                             kwargs['id_dev'] = conf.id
                             kwargs['form'] = form
                             kwargs['title'] = 'Device Configuration'
                             kwargs['suptitle'] = 'Parameters imported'
                             kwargs['button'] = 'Save'
                             kwargs['action'] = conf.get_absolute_url_edit()
                             kwargs['previous'] = conf.get_absolute_url()
                             ###### SIDEBAR ######
                             kwargs.update(sidebar(conf=conf))
                             return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
                     messages.error(request, "Could not import parameters from file")
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['title'] = 'Device Configuration'
                 kwargs['form'] = file_form
                 kwargs['suptitle'] = 'Importing file'
                 kwargs['button'] = 'Import'
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'dev_conf_import.html', kwargs)
             def dev_conf_export(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 conf = DevConfModel.objects.get(pk=id_conf)
                 if request.method == 'GET':
                     file_form = DownloadFileForm(conf.device.device_type.name)
                 if request.method == 'POST':
                     file_form = DownloadFileForm(conf.device.device_type.name, request.POST)
                     if file_form.is_valid():
                         fields = conf.export_to_file(format = file_form.cleaned_data['format'])
                         response = HttpResponse(content_type=fields['content_type'])
                         response['Content-Disposition'] = 'attachment; filename="%s"' %fields['filename']
                         response.write(fields['content'])
                         return response
                     messages.error(request, "Could not export parameters")
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['title'] = 'Device Configuration'
                 kwargs['form'] = file_form
                 kwargs['suptitle'] = 'Exporting file'
                 kwargs['button'] = 'Export'
                 return render(request, 'dev_conf_export.html', kwargs)
             def dev_conf_delete(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if request.method=='POST':
                     if request.user.is_staff:
                         conf.delete()
                         return redirect('url_dev_confs')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(conf.get_absolute_url())
                 kwargs = {
                           'title': 'Delete',
                           'suptitle': 'Experiment',
                           'object': conf,
                           'previous': conf.get_absolute_url(),
                           'delete': True
                           }
                 return render(request, 'confirm.html', kwargs)
             def sidebar(**kwargs):
                 side_data = {}
                 conf = kwargs.get('conf', None)
                 experiment = kwargs.get('experiment', None)
                 if not experiment:
                     experiment = conf.experiment
                 if experiment:
                     side_data['experiment'] = experiment
                     campaign = experiment.campaign_set.all()
                     if campaign:
                         side_data['campaign'] = campaign[0]
                         experiments = campaign[0].experiments.all()
                     else:
                         experiments = [experiment]
                     configurations = experiment.configuration_set.filter(type=0)
                     side_data['side_experiments'] = experiments
                     side_data['side_configurations'] = configurations
                 return side_data
             def operation(request, id_camp=None):
                 if not id_camp:
                     campaigns = Campaign.objects.all().order_by('-start_date')
                     if not campaigns:
                         kwargs = {}
                         kwargs['title'] = 'No Campaigns'
                         kwargs['suptitle'] = 'Empty'
                         return render(request, 'operation.html', kwargs)
                     id_camp = campaigns[0].id
                 campaign = get_object_or_404(Campaign, pk = id_camp)
                 if request.method=='GET':
                     form = OperationForm(initial={'campaign': campaign.id}, length = 5)
                 if request.method=='POST':
                     form = OperationForm(request.POST, initial={'campaign':campaign.id}, length = 5)
                     if form.is_valid():
                         return redirect('url_operation', id_camp=campaign.id)
                 #locations = Location.objects.filter(experiment__campaign__pk = campaign.id).distinct()
                 experiments = Experiment.objects.filter(campaign__pk=campaign.id)
                 #for exs in experiments:
                 #    exs.get_status()
                 locations= Location.objects.filter(experiment=experiments).distinct()
                 #experiments = [Experiment.objects.filter(location__pk=location.id).filter(campaign__pk=campaign.id) for location in locations]
                 kwargs = {}
                 #---Campaign
                 kwargs['campaign'] = campaign
                 kwargs['campaign_keys'] = ['name', 'start_date', 'end_date', 'tags', 'description']
                 #---Experiment
                 keys = ['id', 'name', 'start_time', 'end_time', 'status']
                 kwargs['experiment_keys'] = keys[1:]
                 kwargs['experiments'] = experiments
                 #---Radar
                 kwargs['locations'] = locations
                 #---Else
                 kwargs['title'] = 'Campaign'
                 kwargs['suptitle'] = campaign.name
                 kwargs['form'] = form
                 kwargs['button'] = 'Search'
                 kwargs['details'] = True
                 kwargs['search_button'] = True
                 return render(request, 'operation.html', kwargs)
             def operation_search(request, id_camp=None):
                 if not id_camp:
                     campaigns = Campaign.objects.all().order_by('-start_date')
                     if not campaigns:
                         return render(request, 'operation.html', {})
                     id_camp = campaigns[0].id
                 campaign = get_object_or_404(Campaign, pk = id_camp)
                 if request.method=='GET':
                     form = OperationSearchForm(initial={'campaign': campaign.id})
                 if request.method=='POST':
                     form = OperationSearchForm(request.POST, initial={'campaign':campaign.id})
                     if form.is_valid():
                         return redirect('url_operation', id_camp=campaign.id)
                 #locations = Location.objects.filter(experiment__campaign__pk = campaign.id).distinct()
                 experiments = Experiment.objects.filter(campaign__pk=campaign.id)
                 #for exs in experiments:
                 #    exs.get_status()
                 locations= Location.objects.filter(experiment=experiments).distinct()
                 form = OperationSearchForm(initial={'campaign': campaign.id})
                 kwargs = {}
                 #---Campaign
                 kwargs['campaign'] = campaign
                 kwargs['campaign_keys'] = ['name', 'start_date', 'end_date', 'tags', 'description']
                 #---Experiment
                 keys = ['id', 'name', 'start_time', 'end_time', 'status']
                 kwargs['experiment_keys'] = keys[1:]
                 kwargs['experiments'] = experiments
                 #---Radar
                 kwargs['locations'] = locations
                 #---Else
                 kwargs['title'] = 'Campaign'
                 kwargs['suptitle'] = campaign.name
                 kwargs['form'] = form
                 kwargs['button'] = 'Select'
                 kwargs['details'] = True
                 kwargs['search_button'] = False
                 return render(request, 'operation.html', kwargs)
             def radar_play(request, id_camp, id_radar):
                 campaign = get_object_or_404(Campaign, pk = id_camp)
                 radar = get_object_or_404(Location, pk = id_radar)
                 today = datetime.today()
                 now = today.time()
                 #--Clear Old Experiments From RunningExperiment Object
                 running_experiment = RunningExperiment.objects.filter(radar=radar)
                 if running_experiment:
                     running_experiment = running_experiment[0]
                     running_experiment.running_experiment.clear()
                     running_experiment.save()
                 #--If campaign datetime is ok:
                 if today >= campaign.start_date and today <= campaign.end_date:
                     experiments = Experiment.objects.filter(campaign=campaign).filter(location=radar)
                     for exp in experiments:
                         #--If experiment time is ok:
                         if now >= exp.start_time and now <= exp.end_time:
                             configurations =  Configuration.objects.filter(experiment = exp)
                             for conf in configurations:
                                 if 'cgs' in conf.device.device_type.name:
                                     conf.status_device()
                                 else:
                                     answer = conf.start_device()
                                     conf.status_device()
                                     #--Running Experiment
                                     old_running_experiment = RunningExperiment.objects.filter(radar=radar)
                                     #--If RunningExperiment element exists
                                     if old_running_experiment:
                                         old_running_experiment = old_running_experiment[0]
                                         old_running_experiment.running_experiment.add(exp)
                                         old_running_experiment.status = 3
                                         old_running_experiment.save()
                                     #--Create a new Running_Experiment Object
                                     else:
                                         new_running_experiment = RunningExperiment(
                                                                                radar = radar,
                                                                                status = 3,
                                                                                )
                                         new_running_experiment.save()
                                         new_running_experiment.running_experiment.add(exp)
                                         new_running_experiment.save()
                                     if answer:
                                         messages.success(request, conf.message)
                                         exp.status=2
                                         exp.save()
                                     else:
                                         messages.error(request, conf.message)
                         else:
                             if exp.status == 1 or exp.status == 3:
                                 exp.status=3
                                 exp.save()
                 route = request.META['HTTP_REFERER']
                 route = str(route)
                 if 'search' in route:
                     return HttpResponseRedirect(reverse('url_operation_search', args=[id_camp]))
                 else:
                     return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
             def radar_stop(request, id_camp, id_radar):
                 campaign = get_object_or_404(Campaign, pk = id_camp)
                 radar = get_object_or_404(Location, pk = id_radar)
                 experiments = Experiment.objects.filter(campaign=campaign).filter(location=radar)
                 for exp in experiments:
                     configurations =  Configuration.objects.filter(experiment = exp)
                     for conf in configurations:
                         if 'cgs' in conf.device.device_type.name:
                             conf.status_device()
                         else:
                             answer = conf.stop_device()
                             conf.status_device()
                             if answer:
                                 messages.success(request, conf.message)
                                 exp.status=1
                                 exp.save()
                             else:
                                 messages.error(request, conf.message)
                 route = request.META['HTTP_REFERER']
                 route = str(route)
                 if 'search' in route:
                     return HttpResponseRedirect(reverse('url_operation_search', args=[id_camp]))
                 else:
                     return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
             def radar_refresh(request, id_camp, id_radar):
                 campaign = get_object_or_404(Campaign, pk = id_camp)
                 radar = get_object_or_404(Location, pk = id_radar)
                 experiments = Experiment.objects.filter(campaign=campaign).filter(location=radar)
                 for exs in experiments:
                     exs.get_status()
                 route = request.META['HTTP_REFERER']
                 route = str(route)
                 if 'search' in route:
                     return HttpResponseRedirect(reverse('url_operation_search', args=[id_camp]))
                 else:
                     return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))

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