##// END OF EJS Templates
radarsys
RSS
Se cambio el color de la letra de un panel, y se añadió el timestamp para el momento de crear campañas, cuando duplican experimentos en base a templates
Renato-TUF -
r368:9161d9caff0d
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,818 +1,818
1
1
2 import os
2 import os
3 import json
3 import json
4 import requests
4 import requests
5 import time
5 import time
6 from datetime import datetime
6 from datetime import datetime
7
7
8 try:
8 try:
9 from polymorphic.models import PolymorphicModel
9 from polymorphic.models import PolymorphicModel
10 except:
10 except:
11 from polymorphic import PolymorphicModel
11 from polymorphic import PolymorphicModel
12
12
13 from django.template.base import kwarg_re
13 from django.template.base import kwarg_re
14 from django.db import models
14 from django.db import models
15 from django.urls import reverse
15 from django.urls import reverse
16 from django.core.validators import MinValueValidator, MaxValueValidator
16 from django.core.validators import MinValueValidator, MaxValueValidator
17 from django.shortcuts import get_object_or_404
17 from django.shortcuts import get_object_or_404
18 from django.contrib.auth.models import User
18 from django.contrib.auth.models import User
19 from django.db.models.signals import post_save
19 from django.db.models.signals import post_save
20 from django.dispatch import receiver
20 from django.dispatch import receiver
21
21
22 from apps.main.utils import Params
22 from apps.main.utils import Params
23 from apps.rc.utils import RCFile
23 from apps.rc.utils import RCFile
24 from apps.jars.utils import RacpFile
24 from apps.jars.utils import RacpFile
25 from devices.dds import api as dds_api
25 from devices.dds import api as dds_api
26 from devices.dds import data as dds_data
26 from devices.dds import data as dds_data
27
27
28
28
29 DEV_PORTS = {
29 DEV_PORTS = {
30 'rc' : 2000,
30 'rc' : 2000,
31 'dds' : 2000,
31 'dds' : 2000,
32 'jars' : 2000,
32 'jars' : 2000,
33 'usrp' : 2000,
33 'usrp' : 2000,
34 'cgs' : 8080,
34 'cgs' : 8080,
35 'abs' : 8080,
35 'abs' : 8080,
36 'dds_rest': 80
36 'dds_rest': 80
37 }
37 }
38
38
39 RADAR_STATES = (
39 RADAR_STATES = (
40 (0, 'No connected'),
40 (0, 'No connected'),
41 (1, 'Connected'),
41 (1, 'Connected'),
42 (2, 'Configured'),
42 (2, 'Configured'),
43 (3, 'Running'),
43 (3, 'Running'),
44 (4, 'Scheduled'),
44 (4, 'Scheduled'),
45 )
45 )
46
46
47 EXPERIMENT_TYPE = (
47 EXPERIMENT_TYPE = (
48 (0, 'RAW_DATA'),
48 (0, 'RAW_DATA'),
49 (1, 'PDATA'),
49 (1, 'PDATA'),
50 )
50 )
51
51
52 DECODE_TYPE = (
52 DECODE_TYPE = (
53 (0, 'None'),
53 (0, 'None'),
54 (1, 'TimeDomain'),
54 (1, 'TimeDomain'),
55 (2, 'FreqDomain'),
55 (2, 'FreqDomain'),
56 (3, 'InvFreqDomain'),
56 (3, 'InvFreqDomain'),
57 )
57 )
58
58
59 DEV_STATES = (
59 DEV_STATES = (
60 (0, 'No connected'),
60 (0, 'No connected'),
61 (1, 'Connected'),
61 (1, 'Connected'),
62 (2, 'Configured'),
62 (2, 'Configured'),
63 (3, 'Running'),
63 (3, 'Running'),
64 (4, 'Unknown'),
64 (4, 'Unknown'),
65 )
65 )
66
66
67 DEV_TYPES = (
67 DEV_TYPES = (
68 ('', 'Select a device type'),
68 ('', 'Select a device type'),
69 ('rc', 'Radar Controller'),
69 ('rc', 'Radar Controller'),
70 ('dds', 'Direct Digital Synthesizer'),
70 ('dds', 'Direct Digital Synthesizer'),
71 ('jars', 'Jicamarca Radar Acquisition System'),
71 ('jars', 'Jicamarca Radar Acquisition System'),
72 ('usrp', 'Universal Software Radio Peripheral'),
72 ('usrp', 'Universal Software Radio Peripheral'),
73 ('cgs', 'Clock Generator System'),
73 ('cgs', 'Clock Generator System'),
74 ('abs', 'Automatic Beam Switching'),
74 ('abs', 'Automatic Beam Switching'),
75 ('dds_rest', 'Direct Digital Synthesizer_REST'),
75 ('dds_rest', 'Direct Digital Synthesizer_REST'),
76 )
76 )
77
77
78 EXP_STATES = (
78 EXP_STATES = (
79 (0,'Error'), #RED
79 (0,'Error'), #RED
80 (1,'Cancelled'), #YELLOW
80 (1,'Cancelled'), #YELLOW
81 (2,'Running'), #GREEN
81 (2,'Running'), #GREEN
82 (3,'Scheduled'), #BLUE
82 (3,'Scheduled'), #BLUE
83 (4,'Unknown'), #WHITE
83 (4,'Unknown'), #WHITE
84 )
84 )
85
85
86 CONF_TYPES = (
86 CONF_TYPES = (
87 (0, 'Active'),
87 (0, 'Active'),
88 (1, 'Historical'),
88 (1, 'Historical'),
89 )
89 )
90
90
91 class Profile(models.Model):
91 class Profile(models.Model):
92 user = models.OneToOneField(User, on_delete=models.CASCADE)
92 user = models.OneToOneField(User, on_delete=models.CASCADE)
93 theme = models.CharField(max_length=30, default='spacelab')
93 theme = models.CharField(max_length=30, default='spacelab')
94
94
95
95
96 @receiver(post_save, sender=User)
96 @receiver(post_save, sender=User)
97 def create_user_profile(sender, instance, created, **kwargs):
97 def create_user_profile(sender, instance, created, **kwargs):
98 if created:
98 if created:
99 Profile.objects.create(user=instance)
99 Profile.objects.create(user=instance)
100
100
101 @receiver(post_save, sender=User)
101 @receiver(post_save, sender=User)
102 def save_user_profile(sender, instance, **kwargs):
102 def save_user_profile(sender, instance, **kwargs):
103 instance.profile.save()
103 instance.profile.save()
104
104
105
105
106 class Location(models.Model):
106 class Location(models.Model):
107
107
108 name = models.CharField(max_length = 30)
108 name = models.CharField(max_length = 30)
109 description = models.TextField(blank=True, null=True)
109 description = models.TextField(blank=True, null=True)
110
110
111 class Meta:
111 class Meta:
112 db_table = 'db_location'
112 db_table = 'db_location'
113
113
114 def __str__(self):
114 def __str__(self):
115 return u'%s' % self.name
115 return u'%s' % self.name
116
116
117 def get_absolute_url(self):
117 def get_absolute_url(self):
118 return reverse('url_location', args=[str(self.id)])
118 return reverse('url_location', args=[str(self.id)])
119
119
120
120
121 class DeviceType(models.Model):
121 class DeviceType(models.Model):
122
122
123 name = models.CharField(max_length = 10, choices = DEV_TYPES, default = 'dds_rest')
123 name = models.CharField(max_length = 10, choices = DEV_TYPES, default = 'dds_rest')
124 sequence = models.PositiveSmallIntegerField(default=55)
124 sequence = models.PositiveSmallIntegerField(default=55)
125 description = models.TextField(blank=True, null=True)
125 description = models.TextField(blank=True, null=True)
126
126
127 class Meta:
127 class Meta:
128 db_table = 'db_device_types'
128 db_table = 'db_device_types'
129
129
130 def __str__(self):
130 def __str__(self):
131 return u'%s' % self.get_name_display()
131 return u'%s' % self.get_name_display()
132
132
133 class Device(models.Model):
133 class Device(models.Model):
134
134
135 device_type = models.ForeignKey('DeviceType', on_delete=models.CASCADE)
135 device_type = models.ForeignKey('DeviceType', on_delete=models.CASCADE)
136 location = models.ForeignKey('Location', on_delete=models.CASCADE)
136 location = models.ForeignKey('Location', on_delete=models.CASCADE)
137 ip_address = models.GenericIPAddressField(protocol='IPv4', default='0.0.0.0')
137 ip_address = models.GenericIPAddressField(protocol='IPv4', default='0.0.0.0')
138 port_address = models.PositiveSmallIntegerField(default=2000)
138 port_address = models.PositiveSmallIntegerField(default=2000)
139 description = models.TextField(blank=True, null=True)
139 description = models.TextField(blank=True, null=True)
140 status = models.PositiveSmallIntegerField(default=4, choices=DEV_STATES)
140 status = models.PositiveSmallIntegerField(default=4, choices=DEV_STATES)
141 conf_active = models.PositiveIntegerField(default=0, verbose_name='Current configuration')
141 conf_active = models.PositiveIntegerField(default=0, verbose_name='Current configuration')
142
142
143 class Meta:
143 class Meta:
144 db_table = 'db_devices'
144 db_table = 'db_devices'
145
145
146 def __str__(self):
146 def __str__(self):
147 ret = u'{} [{}]'.format(self.device_type.name.upper(), self.location.name)
147 ret = u'{} [{}]'.format(self.device_type.name.upper(), self.location.name)
148
148
149 return ret
149 return ret
150
150
151 @property
151 @property
152 def name(self):
152 def name(self):
153 return str(self)
153 return str(self)
154
154
155 def get_status(self):
155 def get_status(self):
156 return self.status
156 return self.status
157
157
158 @property
158 @property
159 def status_color(self):
159 def status_color(self):
160 color = 'muted'
160 color = 'muted'
161 if self.status == 0:
161 if self.status == 0:
162 color = "danger"
162 color = "danger"
163 elif self.status == 1:
163 elif self.status == 1:
164 color = "warning"
164 color = "warning"
165 elif self.status == 2:
165 elif self.status == 2:
166 color = "info"
166 color = "info"
167 elif self.status == 3:
167 elif self.status == 3:
168 color = "success"
168 color = "success"
169
169
170 return color
170 return color
171
171
172 def url(self, path=None):
172 def url(self, path=None):
173
173
174 if path:
174 if path:
175 return 'http://{}:{}/{}/'.format(self.ip_address, self.port_address, path)
175 return 'http://{}:{}/{}/'.format(self.ip_address, self.port_address, path)
176 else:
176 else:
177 return 'http://{}:{}/'.format(self.ip_address, self.port_address)
177 return 'http://{}:{}/'.format(self.ip_address, self.port_address)
178
178
179 def get_absolute_url(self):
179 def get_absolute_url(self):
180 return reverse('url_device', args=[str(self.id)])
180 return reverse('url_device', args=[str(self.id)])
181
181
182 def get_absolute_url_edit(self):
182 def get_absolute_url_edit(self):
183 return reverse('url_edit_device', args=[str(self.id)])
183 return reverse('url_edit_device', args=[str(self.id)])
184
184
185 def get_absolute_url_delete(self):
185 def get_absolute_url_delete(self):
186 return reverse('url_delete_device', args=[str(self.id)])
186 return reverse('url_delete_device', args=[str(self.id)])
187
187
188 def change_ip(self, ip_address, mask, gateway, dns, **kwargs):
188 def change_ip(self, ip_address, mask, gateway, dns, **kwargs):
189
189
190 if self.device_type.name=='dds':
190 if self.device_type.name=='dds':
191 try:
191 try:
192 answer = dds_api.change_ip(ip = self.ip_address,
192 answer = dds_api.change_ip(ip = self.ip_address,
193 port = self.port_address,
193 port = self.port_address,
194 new_ip = ip_address,
194 new_ip = ip_address,
195 mask = mask,
195 mask = mask,
196 gateway = gateway)
196 gateway = gateway)
197 if answer[0]=='1':
197 if answer[0]=='1':
198 self.message = '25|DDS - {}'.format(answer)
198 self.message = '25|DDS - {}'.format(answer)
199 self.ip_address = ip_address
199 self.ip_address = ip_address
200 self.save()
200 self.save()
201 else:
201 else:
202 self.message = '30|DDS - {}'.format(answer)
202 self.message = '30|DDS - {}'.format(answer)
203 return False
203 return False
204 except Exception as e:
204 except Exception as e:
205 self.message = '40|{}'.format(str(e))
205 self.message = '40|{}'.format(str(e))
206 return False
206 return False
207
207
208 elif self.device_type.name=='rc':
208 elif self.device_type.name=='rc':
209 headers = {'content-type': "application/json",
209 headers = {'content-type': "application/json",
210 'cache-control': "no-cache"}
210 'cache-control': "no-cache"}
211
211
212 ip = [int(x) for x in ip_address.split('.')]
212 ip = [int(x) for x in ip_address.split('.')]
213 dns = [int(x) for x in dns.split('.')]
213 dns = [int(x) for x in dns.split('.')]
214 gateway = [int(x) for x in gateway.split('.')]
214 gateway = [int(x) for x in gateway.split('.')]
215 subnet = [int(x) for x in mask.split('.')]
215 subnet = [int(x) for x in mask.split('.')]
216
216
217 payload = {
217 payload = {
218 "ip": ip,
218 "ip": ip,
219 "dns": dns,
219 "dns": dns,
220 "gateway": gateway,
220 "gateway": gateway,
221 "subnet": subnet
221 "subnet": subnet
222 }
222 }
223
223
224 req = requests.post(self.url('changeip'), data=json.dumps(payload), headers=headers)
224 req = requests.post(self.url('changeip'), data=json.dumps(payload), headers=headers)
225 try:
225 try:
226 answer = req.json()
226 answer = req.json()
227 if answer['changeip']=='ok':
227 if answer['changeip']=='ok':
228 self.message = '25|IP succesfully changed'
228 self.message = '25|IP succesfully changed'
229 self.ip_address = ip_address
229 self.ip_address = ip_address
230 self.save()
230 self.save()
231 else:
231 else:
232 self.message = '30|An error ocuur when changing IP'
232 self.message = '30|An error ocuur when changing IP'
233 except Exception as e:
233 except Exception as e:
234 self.message = '40|{}'.format(str(e))
234 self.message = '40|{}'.format(str(e))
235 else:
235 else:
236 self.message = 'Not implemented'
236 self.message = 'Not implemented'
237 return False
237 return False
238
238
239 return True
239 return True
240
240
241
241
242 class Campaign(models.Model):
242 class Campaign(models.Model):
243
243
244 template = models.BooleanField(default=False)
244 template = models.BooleanField(default=False)
245 name = models.CharField(max_length=60, unique=True)
245 name = models.CharField(max_length=60, unique=True)
246 start_date = models.DateTimeField(blank=True, null=True)
246 start_date = models.DateTimeField(blank=True, null=True)
247 end_date = models.DateTimeField(blank=True, null=True)
247 end_date = models.DateTimeField(blank=True, null=True)
248 tags = models.CharField(max_length=40, blank=True, null=True)
248 tags = models.CharField(max_length=40, blank=True, null=True)
249 description = models.TextField(blank=True, null=True)
249 description = models.TextField(blank=True, null=True)
250 experiments = models.ManyToManyField('Experiment', blank=True)
250 experiments = models.ManyToManyField('Experiment', blank=True)
251 author = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
251 author = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
252
252
253 class Meta:
253 class Meta:
254 db_table = 'db_campaigns'
254 db_table = 'db_campaigns'
255 ordering = ('name',)
255 ordering = ('name',)
256
256
257 def __str__(self):
257 def __str__(self):
258 if self.template:
258 if self.template:
259 return u'{} (template)'.format(self.name)
259 return u'{} (template)'.format(self.name)
260 else:
260 else:
261 return u'{}'.format(self.name)
261 return u'{}'.format(self.name)
262
262
263 def jsonify(self):
263 def jsonify(self):
264
264
265 data = {}
265 data = {}
266
266
267 ignored = ('template')
267 ignored = ('template')
268
268
269 for field in self._meta.fields:
269 for field in self._meta.fields:
270 if field.name in ignored:
270 if field.name in ignored:
271 continue
271 continue
272 data[field.name] = field.value_from_object(self)
272 data[field.name] = field.value_from_object(self)
273
273
274 data['start_date'] = data['start_date'].strftime('%Y-%m-%d')
274 data['start_date'] = data['start_date'].strftime('%Y-%m-%d')
275 data['end_date'] = data['end_date'].strftime('%Y-%m-%d')
275 data['end_date'] = data['end_date'].strftime('%Y-%m-%d')
276
276
277 return data
277 return data
278
278
279 def parms_to_dict(self):
279 def parms_to_dict(self):
280
280
281 params = Params({})
281 params = Params({})
282 params.add(self.jsonify(), 'campaigns')
282 params.add(self.jsonify(), 'campaigns')
283
283
284 for exp in Experiment.objects.filter(campaign = self):
284 for exp in Experiment.objects.filter(campaign = self):
285 params.add(exp.jsonify(), 'experiments')
285 params.add(exp.jsonify(), 'experiments')
286 configurations = Configuration.objects.filter(experiment=exp, type=0)
286 configurations = Configuration.objects.filter(experiment=exp, type=0)
287
287
288 for conf in configurations:
288 for conf in configurations:
289 params.add(conf.jsonify(), 'configurations')
289 params.add(conf.jsonify(), 'configurations')
290 if conf.device.device_type.name=='rc':
290 if conf.device.device_type.name=='rc':
291 for line in conf.get_lines():
291 for line in conf.get_lines():
292 params.add(line.jsonify(), 'lines')
292 params.add(line.jsonify(), 'lines')
293
293
294 return params.data
294 return params.data
295
295
296 def dict_to_parms(self, parms, CONF_MODELS):
296 def dict_to_parms(self, parms, CONF_MODELS):
297
297
298 experiments = Experiment.objects.filter(campaign = self)
298 experiments = Experiment.objects.filter(campaign = self)
299
299
300 if experiments:
300 if experiments:
301 for experiment in experiments:
301 for experiment in experiments:
302 experiment.delete()
302 experiment.delete()
303
303
304 for id_exp in parms['experiments']['allIds']:
304 for id_exp in parms['experiments']['allIds']:
305 exp_parms = parms['experiments']['byId'][id_exp]
305 exp_parms = parms['experiments']['byId'][id_exp]
306 dum = (datetime.now() - datetime(1970, 1, 1)).total_seconds()
306 dum = (datetime.now() - datetime(1970, 1, 1)).total_seconds()
307 exp = Experiment(name='{}'.format(dum))
307 exp = Experiment(name='{}'.format(dum))
308 exp.save()
308 exp.save()
309 exp.dict_to_parms(parms, CONF_MODELS, id_exp=id_exp)
309 exp.dict_to_parms(parms, CONF_MODELS, id_exp=id_exp)
310 self.experiments.add(exp)
310 self.experiments.add(exp)
311
311
312 camp_parms = parms['campaigns']['byId'][parms['campaigns']['allIds'][0]]
312 camp_parms = parms['campaigns']['byId'][parms['campaigns']['allIds'][0]]
313
313
314 self.name = '{}-{}'.format(camp_parms['name'], datetime.now().strftime('%y%m%d'))
314 self.name = '{}-{}'.format(camp_parms['name'], datetime.now().strftime('%y%m%d'))
315 self.start_date = camp_parms['start_date']
315 self.start_date = camp_parms['start_date']
316 self.end_date = camp_parms['end_date']
316 self.end_date = camp_parms['end_date']
317 self.tags = camp_parms['tags']
317 self.tags = camp_parms['tags']
318 self.save()
318 self.save()
319
319
320 return self
320 return self
321
321
322 def get_experiments_by_radar(self, radar=None):
322 def get_experiments_by_radar(self, radar=None):
323
323
324 ret = []
324 ret = []
325 if radar:
325 if radar:
326 locations = Location.objects.filter(pk=radar)
326 locations = Location.objects.filter(pk=radar)
327 else:
327 else:
328 locations = set([e.location for e in self.experiments.all()])
328 locations = set([e.location for e in self.experiments.all()])
329
329
330 for loc in locations:
330 for loc in locations:
331 dum = {}
331 dum = {}
332 dum['name'] = loc.name
332 dum['name'] = loc.name
333 dum['id'] = loc.pk
333 dum['id'] = loc.pk
334 dum['experiments'] = [e for e in self.experiments.all() if e.location==loc]
334 dum['experiments'] = [e for e in self.experiments.all() if e.location==loc]
335 ret.append(dum)
335 ret.append(dum)
336
336
337 return ret
337 return ret
338
338
339 def get_absolute_url(self):
339 def get_absolute_url(self):
340 return reverse('url_campaign', args=[str(self.id)])
340 return reverse('url_campaign', args=[str(self.id)])
341
341
342 def get_absolute_url_edit(self):
342 def get_absolute_url_edit(self):
343 return reverse('url_edit_campaign', args=[str(self.id)])
343 return reverse('url_edit_campaign', args=[str(self.id)])
344
344
345 def get_absolute_url_delete(self):
345 def get_absolute_url_delete(self):
346 return reverse('url_delete_campaign', args=[str(self.id)])
346 return reverse('url_delete_campaign', args=[str(self.id)])
347
347
348 def get_absolute_url_export(self):
348 def get_absolute_url_export(self):
349 return reverse('url_export_campaign', args=[str(self.id)])
349 return reverse('url_export_campaign', args=[str(self.id)])
350
350
351 def get_absolute_url_import(self):
351 def get_absolute_url_import(self):
352 return reverse('url_import_campaign', args=[str(self.id)])
352 return reverse('url_import_campaign', args=[str(self.id)])
353
353
354
354
355 class RunningExperiment(models.Model):
355 class RunningExperiment(models.Model):
356 radar = models.OneToOneField('Location', on_delete=models.CASCADE)
356 radar = models.OneToOneField('Location', on_delete=models.CASCADE)
357 running_experiment = models.ManyToManyField('Experiment', blank = True)
357 running_experiment = models.ManyToManyField('Experiment', blank = True)
358 status = models.PositiveSmallIntegerField(default=0, choices=RADAR_STATES)
358 status = models.PositiveSmallIntegerField(default=0, choices=RADAR_STATES)
359
359
360
360
361 class Experiment(models.Model):
361 class Experiment(models.Model):
362
362
363 template = models.BooleanField(default=False)
363 template = models.BooleanField(default=False)
364 name = models.CharField(max_length=40, default='', unique=True)
364 name = models.CharField(max_length=40, default='', unique=True)
365 location = models.ForeignKey('Location', null=True, blank=True, on_delete=models.CASCADE)
365 location = models.ForeignKey('Location', null=True, blank=True, on_delete=models.CASCADE)
366 freq = models.FloatField(verbose_name='Operating Freq. (MHz)', validators=[MinValueValidator(1), MaxValueValidator(10000)], default=49.9200)
366 freq = models.FloatField(verbose_name='Operating Freq. (MHz)', validators=[MinValueValidator(1), MaxValueValidator(10000)], default=49.9200)
367 start_time = models.TimeField(default='00:00:00')
367 start_time = models.TimeField(default='00:00:00')
368 end_time = models.TimeField(default='23:59:59')
368 end_time = models.TimeField(default='23:59:59')
369 task = models.CharField(max_length=36, default='', blank=True, null=True)
369 task = models.CharField(max_length=36, default='', blank=True, null=True)
370 status = models.PositiveSmallIntegerField(default=4, choices=EXP_STATES)
370 status = models.PositiveSmallIntegerField(default=4, choices=EXP_STATES)
371 author = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
371 author = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
372 hash = models.CharField(default='', max_length=64, null=True, blank=True)
372 hash = models.CharField(default='', max_length=64, null=True, blank=True)
373
373
374 class Meta:
374 class Meta:
375 db_table = 'db_experiments'
375 db_table = 'db_experiments'
376 ordering = ('template', 'name')
376 ordering = ('template', 'name')
377
377
378 def __str__(self):
378 def __str__(self):
379 if self.template:
379 if self.template:
380 return u'%s (template)' % (self.name)
380 return u'%s (template)' % (self.name)
381 else:
381 else:
382 return u'%s' % (self.name)
382 return u'%s' % (self.name)
383
383
384 def jsonify(self):
384 def jsonify(self):
385
385
386 data = {}
386 data = {}
387
387
388 ignored = ('template')
388 ignored = ('template')
389
389
390 for field in self._meta.fields:
390 for field in self._meta.fields:
391 if field.name in ignored:
391 if field.name in ignored:
392 continue
392 continue
393 data[field.name] = field.value_from_object(self)
393 data[field.name] = field.value_from_object(self)
394
394
395 data['start_time'] = data['start_time'].strftime('%H:%M:%S')
395 data['start_time'] = data['start_time'].strftime('%H:%M:%S')
396 data['end_time'] = data['end_time'].strftime('%H:%M:%S')
396 data['end_time'] = data['end_time'].strftime('%H:%M:%S')
397 data['location'] = self.location.name
397 data['location'] = self.location.name
398 data['configurations'] = ['{}'.format(conf.pk) for
398 data['configurations'] = ['{}'.format(conf.pk) for
399 conf in Configuration.objects.filter(experiment=self, type=0)]
399 conf in Configuration.objects.filter(experiment=self, type=0)]
400
400
401 return data
401 return data
402
402
403 @property
403 @property
404 def radar_system(self):
404 def radar_system(self):
405 return self.location
405 return self.location
406
406
407 def clone(self, **kwargs):
407 def clone(self, **kwargs):
408
408
409 confs = Configuration.objects.filter(experiment=self, type=0)
409 confs = Configuration.objects.filter(experiment=self, type=0)
410 self.pk = None
410 self.pk = None
411 self.name = '{}_{:%y%m%d}'.format(self.name, datetime.now())
411 self.name = '{}_{:%y%m%d%H%M%S}'.format(self.name, datetime.now())
412 for attr, value in kwargs.items():
412 for attr, value in kwargs.items():
413 setattr(self, attr, value)
413 setattr(self, attr, value)
414
414
415 self.save()
415 self.save()
416
416
417 for conf in confs:
417 for conf in confs:
418 conf.clone(experiment=self, template=False)
418 conf.clone(experiment=self, template=False)
419
419
420 return self
420 return self
421
421
422 def start(self):
422 def start(self):
423 '''
423 '''
424 Configure and start experiments's devices
424 Configure and start experiments's devices
425 ABS-CGS-DDS-RC-JARS
425 ABS-CGS-DDS-RC-JARS
426 '''
426 '''
427
427
428 confs = []
428 confs = []
429 allconfs = Configuration.objects.filter(experiment=self, type = 0).order_by('-device__device_type__sequence')
429 allconfs = Configuration.objects.filter(experiment=self, type = 0).order_by('-device__device_type__sequence')
430 rc_mix = [conf for conf in allconfs if conf.device.device_type.name=='rc' and conf.mix]
430 rc_mix = [conf for conf in allconfs if conf.device.device_type.name=='rc' and conf.mix]
431 if rc_mix:
431 if rc_mix:
432 for conf in allconfs:
432 for conf in allconfs:
433 if conf.device.device_type.name == 'rc' and not conf.mix:
433 if conf.device.device_type.name == 'rc' and not conf.mix:
434 continue
434 continue
435 confs.append(conf)
435 confs.append(conf)
436 else:
436 else:
437 confs = allconfs
437 confs = allconfs
438
438
439 print("confs: ",confs)
439 print("confs: ",confs)
440 #try:
440 #try:
441 for conf in confs:
441 for conf in confs:
442 print("conf->",conf)
442 print("conf->",conf)
443 conf.stop_device()
443 conf.stop_device()
444 conf.write_device()
444 conf.write_device()
445 conf.device.conf_active = conf.pk
445 conf.device.conf_active = conf.pk
446 conf.device.save()
446 conf.device.save()
447 conf.start_device()
447 conf.start_device()
448 time.sleep(1)
448 time.sleep(1)
449 #except:
449 #except:
450 #return 0
450 #return 0
451 return 2
451 return 2
452
452
453
453
454 def stop(self):
454 def stop(self):
455 '''
455 '''
456 Stop experiments's devices
456 Stop experiments's devices
457 DDS-JARS-RC-CGS-ABS
457 DDS-JARS-RC-CGS-ABS
458 '''
458 '''
459
459
460 confs = Configuration.objects.filter(experiment=self, type = 0).order_by('device__device_type__sequence')
460 confs = Configuration.objects.filter(experiment=self, type = 0).order_by('device__device_type__sequence')
461 confs = confs.exclude(device__device_type__name='cgs')
461 confs = confs.exclude(device__device_type__name='cgs')
462 try:
462 try:
463 for conf in confs:
463 for conf in confs:
464 conf.stop_device()
464 conf.stop_device()
465 except:
465 except:
466 return 0
466 return 0
467 return 1
467 return 1
468
468
469 def get_status(self):
469 def get_status(self):
470
470
471 if self.status == 3:
471 if self.status == 3:
472 return
472 return
473
473
474 confs = Configuration.objects.filter(experiment=self, type=0)
474 confs = Configuration.objects.filter(experiment=self, type=0)
475
475
476 for conf in confs:
476 for conf in confs:
477 conf.status_device()
477 conf.status_device()
478
478
479 total = confs.aggregate(models.Sum('device__status'))['device__status__sum']
479 total = confs.aggregate(models.Sum('device__status'))['device__status__sum']
480
480
481 if total==2*confs.count():
481 if total==2*confs.count():
482 status = 1
482 status = 1
483 elif total == 3*confs.count():
483 elif total == 3*confs.count():
484 status = 2
484 status = 2
485 else:
485 else:
486 status = 0
486 status = 0
487
487
488 self.status = status
488 self.status = status
489 self.save()
489 self.save()
490
490
491 def status_color(self):
491 def status_color(self):
492 color = 'muted'
492 color = 'muted'
493 if self.status == 0:
493 if self.status == 0:
494 color = "danger"
494 color = "danger"
495 elif self.status == 1:
495 elif self.status == 1:
496 color = "warning"
496 color = "warning"
497 elif self.status == 2:
497 elif self.status == 2:
498 color = "success"
498 color = "success"
499 elif self.status == 3:
499 elif self.status == 3:
500 color = "info"
500 color = "info"
501
501
502 return color
502 return color
503
503
504 def parms_to_dict(self):
504 def parms_to_dict(self):
505
505
506 params = Params({})
506 params = Params({})
507 params.add(self.jsonify(), 'experiments')
507 params.add(self.jsonify(), 'experiments')
508
508
509 configurations = Configuration.objects.filter(experiment=self, type=0)
509 configurations = Configuration.objects.filter(experiment=self, type=0)
510
510
511 for conf in configurations:
511 for conf in configurations:
512 params.add(conf.jsonify(), 'configurations')
512 params.add(conf.jsonify(), 'configurations')
513 if conf.device.device_type.name=='rc':
513 if conf.device.device_type.name=='rc':
514 for line in conf.get_lines():
514 for line in conf.get_lines():
515 params.add(line.jsonify(), 'lines')
515 params.add(line.jsonify(), 'lines')
516
516
517 return params.data
517 return params.data
518
518
519 def dict_to_parms(self, parms, CONF_MODELS, id_exp=None):
519 def dict_to_parms(self, parms, CONF_MODELS, id_exp=None):
520
520
521 configurations = Configuration.objects.filter(experiment=self)
521 configurations = Configuration.objects.filter(experiment=self)
522
522
523 if id_exp is not None:
523 if id_exp is not None:
524 exp_parms = parms['experiments']['byId'][id_exp]
524 exp_parms = parms['experiments']['byId'][id_exp]
525 else:
525 else:
526 exp_parms = parms['experiments']['byId'][parms['experiments']['allIds'][0]]
526 exp_parms = parms['experiments']['byId'][parms['experiments']['allIds'][0]]
527
527
528 if configurations:
528 if configurations:
529 for configuration in configurations:
529 for configuration in configurations:
530 configuration.delete()
530 configuration.delete()
531
531
532 for id_conf in exp_parms['configurations']:
532 for id_conf in exp_parms['configurations']:
533 conf_parms = parms['configurations']['byId'][id_conf]
533 conf_parms = parms['configurations']['byId'][id_conf]
534 device = Device.objects.filter(device_type__name=conf_parms['device_type'])[0]
534 device = Device.objects.filter(device_type__name=conf_parms['device_type'])[0]
535 model = CONF_MODELS[conf_parms['device_type']]
535 model = CONF_MODELS[conf_parms['device_type']]
536 conf = model(
536 conf = model(
537 experiment = self,
537 experiment = self,
538 device = device,
538 device = device,
539 )
539 )
540 conf.dict_to_parms(parms, id=id_conf)
540 conf.dict_to_parms(parms, id=id_conf)
541
541
542
542
543 location, created = Location.objects.get_or_create(name=exp_parms['location'])
543 location, created = Location.objects.get_or_create(name=exp_parms['location'])
544 self.name = '{}-{}'.format(exp_parms['name'], datetime.now().strftime('%y%m%d'))
544 self.name = '{}-{}'.format(exp_parms['name'], datetime.now().strftime('%y%m%d'))
545 self.location = location
545 self.location = location
546 self.start_time = exp_parms['start_time']
546 self.start_time = exp_parms['start_time']
547 self.end_time = exp_parms['end_time']
547 self.end_time = exp_parms['end_time']
548 self.save()
548 self.save()
549
549
550 return self
550 return self
551
551
552 def get_absolute_url(self):
552 def get_absolute_url(self):
553 return reverse('url_experiment', args=[str(self.id)])
553 return reverse('url_experiment', args=[str(self.id)])
554
554
555 def get_absolute_url_edit(self):
555 def get_absolute_url_edit(self):
556 return reverse('url_edit_experiment', args=[str(self.id)])
556 return reverse('url_edit_experiment', args=[str(self.id)])
557
557
558 def get_absolute_url_delete(self):
558 def get_absolute_url_delete(self):
559 return reverse('url_delete_experiment', args=[str(self.id)])
559 return reverse('url_delete_experiment', args=[str(self.id)])
560
560
561 def get_absolute_url_import(self):
561 def get_absolute_url_import(self):
562 return reverse('url_import_experiment', args=[str(self.id)])
562 return reverse('url_import_experiment', args=[str(self.id)])
563
563
564 def get_absolute_url_export(self):
564 def get_absolute_url_export(self):
565 return reverse('url_export_experiment', args=[str(self.id)])
565 return reverse('url_export_experiment', args=[str(self.id)])
566
566
567 def get_absolute_url_start(self):
567 def get_absolute_url_start(self):
568 return reverse('url_start_experiment', args=[str(self.id)])
568 return reverse('url_start_experiment', args=[str(self.id)])
569
569
570 def get_absolute_url_stop(self):
570 def get_absolute_url_stop(self):
571 return reverse('url_stop_experiment', args=[str(self.id)])
571 return reverse('url_stop_experiment', args=[str(self.id)])
572
572
573
573
574 class Configuration(PolymorphicModel):
574 class Configuration(PolymorphicModel):
575
575
576 template = models.BooleanField(default=False)
576 template = models.BooleanField(default=False)
577 # name = models.CharField(verbose_name="Configuration Name", max_length=40, default='')
577 # name = models.CharField(verbose_name="Configuration Name", max_length=40, default='')
578 device = models.ForeignKey('Device', verbose_name='Device', null=True, on_delete=models.CASCADE)
578 device = models.ForeignKey('Device', verbose_name='Device', null=True, on_delete=models.CASCADE)
579 label = models.CharField(verbose_name="Label", max_length=40, default='', blank=True, null=True)
579 label = models.CharField(verbose_name="Label", max_length=40, default='', blank=True, null=True)
580 experiment = models.ForeignKey('Experiment', verbose_name='Experiment', null=True, blank=True, on_delete=models.CASCADE)
580 experiment = models.ForeignKey('Experiment', verbose_name='Experiment', null=True, blank=True, on_delete=models.CASCADE)
581 type = models.PositiveSmallIntegerField(default=0, choices=CONF_TYPES)
581 type = models.PositiveSmallIntegerField(default=0, choices=CONF_TYPES)
582 created_date = models.DateTimeField(auto_now_add=True)
582 created_date = models.DateTimeField(auto_now_add=True)
583 programmed_date = models.DateTimeField(auto_now=True)
583 programmed_date = models.DateTimeField(auto_now=True)
584 parameters = models.TextField(default='{}')
584 parameters = models.TextField(default='{}')
585 author = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
585 author = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
586 hash = models.CharField(default='', max_length=64, null=True, blank=True)
586 hash = models.CharField(default='', max_length=64, null=True, blank=True)
587 message = ""
587 message = ""
588
588
589 class Meta:
589 class Meta:
590 db_table = 'db_configurations'
590 db_table = 'db_configurations'
591 ordering = ('device__device_type__name',)
591 ordering = ('device__device_type__name',)
592
592
593 def __str__(self):
593 def __str__(self):
594
594
595 ret = u'{} '.format(self.device.device_type.name.upper())
595 ret = u'{} '.format(self.device.device_type.name.upper())
596
596
597 if 'mix' in [f.name for f in self._meta.get_fields()]:
597 if 'mix' in [f.name for f in self._meta.get_fields()]:
598 if self.mix:
598 if self.mix:
599 ret = '{} MIX '.format(self.device.device_type.name.upper())
599 ret = '{} MIX '.format(self.device.device_type.name.upper())
600
600
601 if 'label' in [f.name for f in self._meta.get_fields()]:
601 if 'label' in [f.name for f in self._meta.get_fields()]:
602 ret += '{}'.format(self.label)
602 ret += '{}'.format(self.label)
603
603
604 if self.template:
604 if self.template:
605 ret += ' (template)'
605 ret += ' (template)'
606
606
607 return ret
607 return ret
608
608
609 @property
609 @property
610 def name(self):
610 def name(self):
611
611
612 return str(self)
612 return str(self)
613
613
614 def jsonify(self):
614 def jsonify(self):
615
615
616 data = {}
616 data = {}
617
617
618 ignored = ('type', 'polymorphic_ctype', 'configuration_ptr',
618 ignored = ('type', 'polymorphic_ctype', 'configuration_ptr',
619 'created_date', 'programmed_date', 'template', 'device',
619 'created_date', 'programmed_date', 'template', 'device',
620 'experiment')
620 'experiment')
621
621
622 for field in self._meta.fields:
622 for field in self._meta.fields:
623 if field.name in ignored:
623 if field.name in ignored:
624 continue
624 continue
625 data[field.name] = field.value_from_object(self)
625 data[field.name] = field.value_from_object(self)
626
626
627 data['device_type'] = self.device.device_type.name
627 data['device_type'] = self.device.device_type.name
628
628
629 if self.device.device_type.name == 'rc':
629 if self.device.device_type.name == 'rc':
630 data['lines'] = ['{}'.format(line.pk) for line in self.get_lines()]
630 data['lines'] = ['{}'.format(line.pk) for line in self.get_lines()]
631 data['delays'] = self.get_delays()
631 data['delays'] = self.get_delays()
632 data['pulses'] = self.get_pulses()
632 data['pulses'] = self.get_pulses()
633
633
634 elif self.device.device_type.name == 'jars':
634 elif self.device.device_type.name == 'jars':
635 data['decode_type'] = DECODE_TYPE[self.decode_data][1]
635 data['decode_type'] = DECODE_TYPE[self.decode_data][1]
636
636
637 elif self.device.device_type.name == 'dds':
637 elif self.device.device_type.name == 'dds':
638 data['frequencyA_Mhz'] = float(data['frequencyA_Mhz'])
638 data['frequencyA_Mhz'] = float(data['frequencyA_Mhz'])
639 data['frequencyB_Mhz'] = float(data['frequencyB_Mhz'])
639 data['frequencyB_Mhz'] = float(data['frequencyB_Mhz'])
640 data['phaseA'] = dds_data.phase_to_binary(data['phaseA_degrees'])
640 data['phaseA'] = dds_data.phase_to_binary(data['phaseA_degrees'])
641 data['phaseB'] = dds_data.phase_to_binary(data['phaseB_degrees'])
641 data['phaseB'] = dds_data.phase_to_binary(data['phaseB_degrees'])
642
642
643 elif self.device.device_type.name == 'dds_rest':
643 elif self.device.device_type.name == 'dds_rest':
644 data['frequencyA_Mhz'] = float(data['frequencyA_Mhz'])
644 data['frequencyA_Mhz'] = float(data['frequencyA_Mhz'])
645 data['frequencyB_Mhz'] = float(data['frequencyB_Mhz'])
645 data['frequencyB_Mhz'] = float(data['frequencyB_Mhz'])
646 data['phaseA'] = dds_data.phase_to_binary(data['phaseA_degrees'])
646 data['phaseA'] = dds_data.phase_to_binary(data['phaseA_degrees'])
647 data['phaseB'] = dds_data.phase_to_binary(data['phaseB_degrees'])
647 data['phaseB'] = dds_data.phase_to_binary(data['phaseB_degrees'])
648 data['delta_frequency_Mhz'] = float(data['delta_frequency_Mhz'] or 0.00)
648 data['delta_frequency_Mhz'] = float(data['delta_frequency_Mhz'] or 0.00)
649 data['update_clock_Mhz'] = float(data['update_clock_Mhz'] or 0.00)
649 data['update_clock_Mhz'] = float(data['update_clock_Mhz'] or 0.00)
650 data['ramp_rate_clock_Mhz'] = float(data['ramp_rate_clock_Mhz'] or 0.0)
650 data['ramp_rate_clock_Mhz'] = float(data['ramp_rate_clock_Mhz'] or 0.0)
651 return data
651 return data
652
652
653 def clone(self, **kwargs):
653 def clone(self, **kwargs):
654
654
655 self.pk = None
655 self.pk = None
656 self.id = None
656 self.id = None
657 for attr, value in kwargs.items():
657 for attr, value in kwargs.items():
658 setattr(self, attr, value)
658 setattr(self, attr, value)
659
659
660 self.save()
660 self.save()
661
661
662 return self
662 return self
663
663
664 def parms_to_dict(self):
664 def parms_to_dict(self):
665
665
666 params = Params({})
666 params = Params({})
667 params.add(self.jsonify(), 'configurations')
667 params.add(self.jsonify(), 'configurations')
668
668
669 if self.device.device_type.name=='rc':
669 if self.device.device_type.name=='rc':
670 for line in self.get_lines():
670 for line in self.get_lines():
671 params.add(line.jsonify(), 'lines')
671 params.add(line.jsonify(), 'lines')
672
672
673 return params.data
673 return params.data
674
674
675 def parms_to_text(self):
675 def parms_to_text(self):
676
676
677 raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
677 raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
678
678
679
679
680 def parms_to_binary(self):
680 def parms_to_binary(self):
681
681
682 raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
682 raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
683
683
684
684
685 def dict_to_parms(self, parameters, id=None):
685 def dict_to_parms(self, parameters, id=None):
686
686
687 params = Params(parameters)
687 params = Params(parameters)
688
688
689 if id:
689 if id:
690 data = params.get_conf(id_conf=id)
690 data = params.get_conf(id_conf=id)
691 else:
691 else:
692 data = params.get_conf(dtype=self.device.device_type.name)
692 data = params.get_conf(dtype=self.device.device_type.name)
693
693
694 if data['device_type']=='rc':
694 if data['device_type']=='rc':
695 self.clean_lines()
695 self.clean_lines()
696 lines = data.pop('lines', None)
696 lines = data.pop('lines', None)
697 for line_id in lines:
697 for line_id in lines:
698 pass
698 pass
699
699
700 for key, value in data.items():
700 for key, value in data.items():
701 if key not in ('id', 'device_type'):
701 if key not in ('id', 'device_type'):
702 setattr(self, key, value)
702 setattr(self, key, value)
703
703
704 self.save()
704 self.save()
705
705
706
706
707 def export_to_file(self, format="json"):
707 def export_to_file(self, format="json"):
708
708
709 content_type = ''
709 content_type = ''
710
710
711 if format == 'racp':
711 if format == 'racp':
712 content_type = 'text/plain'
712 content_type = 'text/plain'
713 filename = '%s_%s.%s' %(self.device.device_type.name, self.name, 'racp')
713 filename = '%s_%s.%s' %(self.device.device_type.name, self.name, 'racp')
714 content = self.parms_to_text(file_format = 'racp')
714 content = self.parms_to_text(file_format = 'racp')
715
715
716 if format == 'text':
716 if format == 'text':
717 content_type = 'text/plain'
717 content_type = 'text/plain'
718 filename = '%s_%s.%s' %(self.device.device_type.name, self.name, self.device.device_type.name)
718 filename = '%s_%s.%s' %(self.device.device_type.name, self.name, self.device.device_type.name)
719 content = self.parms_to_text()
719 content = self.parms_to_text()
720
720
721 if format == 'binary':
721 if format == 'binary':
722 content_type = 'application/octet-stream'
722 content_type = 'application/octet-stream'
723 filename = '%s_%s.bin' %(self.device.device_type.name, self.name)
723 filename = '%s_%s.bin' %(self.device.device_type.name, self.name)
724 content = self.parms_to_binary()
724 content = self.parms_to_binary()
725
725
726 if not content_type:
726 if not content_type:
727 content_type = 'application/json'
727 content_type = 'application/json'
728 filename = '%s_%s.json' %(self.device.device_type.name, self.name)
728 filename = '%s_%s.json' %(self.device.device_type.name, self.name)
729 content = json.dumps(self.parms_to_dict(), indent=2)
729 content = json.dumps(self.parms_to_dict(), indent=2)
730
730
731 fields = {'content_type':content_type,
731 fields = {'content_type':content_type,
732 'filename':filename,
732 'filename':filename,
733 'content':content
733 'content':content
734 }
734 }
735
735
736 return fields
736 return fields
737
737
738 def import_from_file(self, fp):
738 def import_from_file(self, fp):
739
739
740 parms = {}
740 parms = {}
741
741
742 path, ext = os.path.splitext(fp.name)
742 path, ext = os.path.splitext(fp.name)
743
743
744 if ext == '.json':
744 if ext == '.json':
745 parms = json.load(fp)
745 parms = json.load(fp)
746
746
747 if ext == '.dds':
747 if ext == '.dds':
748 lines = fp.readlines()
748 lines = fp.readlines()
749 parms = dds_data.text_to_dict(lines)
749 parms = dds_data.text_to_dict(lines)
750
750
751 if ext == '.racp':
751 if ext == '.racp':
752 if self.device.device_type.name == 'jars':
752 if self.device.device_type.name == 'jars':
753 parms = RacpFile(fp).to_dict()
753 parms = RacpFile(fp).to_dict()
754 parms['filter_parms'] = json.loads(self.filter_parms)
754 parms['filter_parms'] = json.loads(self.filter_parms)
755 return parms
755 return parms
756 parms = RCFile(fp).to_dict()
756 parms = RCFile(fp).to_dict()
757
757
758 return parms
758 return parms
759
759
760 def status_device(self):
760 def status_device(self):
761
761
762 self.message = 'Function not implemented'
762 self.message = 'Function not implemented'
763 return False
763 return False
764
764
765
765
766 def stop_device(self):
766 def stop_device(self):
767
767
768 self.message = 'Function not implemented'
768 self.message = 'Function not implemented'
769 return False
769 return False
770
770
771
771
772 def start_device(self):
772 def start_device(self):
773
773
774 self.message = 'Function not implemented'
774 self.message = 'Function not implemented'
775 return False
775 return False
776
776
777
777
778 def write_device(self, parms):
778 def write_device(self, parms):
779
779
780 self.message = 'Function not implemented'
780 self.message = 'Function not implemented'
781 return False
781 return False
782
782
783
783
784 def read_device(self):
784 def read_device(self):
785
785
786 self.message = 'Function not implemented'
786 self.message = 'Function not implemented'
787 return False
787 return False
788
788
789
789
790 def get_absolute_url(self):
790 def get_absolute_url(self):
791 return reverse('url_%s_conf' % self.device.device_type.name, args=[str(self.id)])
791 return reverse('url_%s_conf' % self.device.device_type.name, args=[str(self.id)])
792
792
793 def get_absolute_url_edit(self):
793 def get_absolute_url_edit(self):
794 return reverse('url_edit_%s_conf' % self.device.device_type.name, args=[str(self.id)])
794 return reverse('url_edit_%s_conf' % self.device.device_type.name, args=[str(self.id)])
795
795
796 def get_absolute_url_delete(self):
796 def get_absolute_url_delete(self):
797 return reverse('url_delete_dev_conf', args=[str(self.id)])
797 return reverse('url_delete_dev_conf', args=[str(self.id)])
798
798
799 def get_absolute_url_import(self):
799 def get_absolute_url_import(self):
800 return reverse('url_import_dev_conf', args=[str(self.id)])
800 return reverse('url_import_dev_conf', args=[str(self.id)])
801
801
802 def get_absolute_url_export(self):
802 def get_absolute_url_export(self):
803 return reverse('url_export_dev_conf', args=[str(self.id)])
803 return reverse('url_export_dev_conf', args=[str(self.id)])
804
804
805 def get_absolute_url_write(self):
805 def get_absolute_url_write(self):
806 return reverse('url_write_dev_conf', args=[str(self.id)])
806 return reverse('url_write_dev_conf', args=[str(self.id)])
807
807
808 def get_absolute_url_read(self):
808 def get_absolute_url_read(self):
809 return reverse('url_read_dev_conf', args=[str(self.id)])
809 return reverse('url_read_dev_conf', args=[str(self.id)])
810
810
811 def get_absolute_url_start(self):
811 def get_absolute_url_start(self):
812 return reverse('url_start_dev_conf', args=[str(self.id)])
812 return reverse('url_start_dev_conf', args=[str(self.id)])
813
813
814 def get_absolute_url_stop(self):
814 def get_absolute_url_stop(self):
815 return reverse('url_stop_dev_conf', args=[str(self.id)])
815 return reverse('url_stop_dev_conf', args=[str(self.id)])
816
816
817 def get_absolute_url_status(self):
817 def get_absolute_url_status(self):
818 return reverse('url_status_dev_conf', args=[str(self.id)])
818 return reverse('url_status_dev_conf', args=[str(self.id)])
Show file before | Show file after | Hide comments
@@ -1,2029 +1,2029
1 import ast
1 import ast
2 import json
2 import json
3 import hashlib
3 import hashlib
4 from datetime import datetime, timedelta
4 from datetime import datetime, timedelta
5
5
6 from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
6 from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
7 from django.utils.safestring import mark_safe
7 from django.utils.safestring import mark_safe
8 from django.http import HttpResponseRedirect
8 from django.http import HttpResponseRedirect
9 from django.urls import reverse
9 from django.urls import reverse
10 from django.db.models import Q
10 from django.db.models import Q
11 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
11 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
12 from django.contrib import messages
12 from django.contrib import messages
13 from django.http.request import QueryDict
13 from django.http.request import QueryDict
14 from django.contrib.auth.decorators import login_required, user_passes_test
14 from django.contrib.auth.decorators import login_required, user_passes_test
15
15
16 from django.utils.timezone import is_aware
16 from django.utils.timezone import is_aware
17
17
18 try:
18 try:
19 from urllib.parse import urlencode
19 from urllib.parse import urlencode
20 except ImportError:
20 except ImportError:
21 from urllib import urlencode
21 from urllib import urlencode
22
22
23 from .forms import CampaignForm, ExperimentForm, DeviceForm, ConfigurationForm, LocationForm, UploadFileForm, DownloadFileForm, OperationForm, NewForm
23 from .forms import CampaignForm, ExperimentForm, DeviceForm, ConfigurationForm, LocationForm, UploadFileForm, DownloadFileForm, OperationForm, NewForm
24 from .forms import OperationSearchForm, FilterForm, ChangeIpForm
24 from .forms import OperationSearchForm, FilterForm, ChangeIpForm
25
25
26 from apps.rc.forms import RCConfigurationForm, RCLineCode, RCMixConfigurationForm
26 from apps.rc.forms import RCConfigurationForm, RCLineCode, RCMixConfigurationForm
27 from apps.dds.forms import DDSConfigurationForm
27 from apps.dds.forms import DDSConfigurationForm
28 from apps.jars.forms import JARSConfigurationForm
28 from apps.jars.forms import JARSConfigurationForm
29 from apps.cgs.forms import CGSConfigurationForm
29 from apps.cgs.forms import CGSConfigurationForm
30 from apps.abs.forms import ABSConfigurationForm
30 from apps.abs.forms import ABSConfigurationForm
31 from apps.usrp.forms import USRPConfigurationForm
31 from apps.usrp.forms import USRPConfigurationForm
32 from apps.dds_rest.forms import DDSRestConfigurationForm
32 from apps.dds_rest.forms import DDSRestConfigurationForm
33 from .utils import Params
33 from .utils import Params
34
34
35 from .models import Campaign, Experiment, Device, Configuration, Location, RunningExperiment, DEV_STATES
35 from .models import Campaign, Experiment, Device, Configuration, Location, RunningExperiment, DEV_STATES
36 from apps.cgs.models import CGSConfiguration
36 from apps.cgs.models import CGSConfiguration
37 from apps.jars.models import JARSConfiguration, EXPERIMENT_TYPE
37 from apps.jars.models import JARSConfiguration, EXPERIMENT_TYPE
38 from apps.usrp.models import USRPConfiguration
38 from apps.usrp.models import USRPConfiguration
39 from apps.abs.models import ABSConfiguration
39 from apps.abs.models import ABSConfiguration
40 from apps.rc.models import RCConfiguration, RCLine, RCLineType, RCClock
40 from apps.rc.models import RCConfiguration, RCLine, RCLineType, RCClock
41 from apps.dds.models import DDSConfiguration
41 from apps.dds.models import DDSConfiguration
42 from apps.dds_rest.models import DDSRestConfiguration
42 from apps.dds_rest.models import DDSRestConfiguration
43
43
44 #from .tasks import task_start
44 #from .tasks import task_start
45 from radarsys.celery import app
45 from radarsys.celery import app
46
46
47 #comentario test
47 #comentario test
48 CONF_FORMS = {
48 CONF_FORMS = {
49 'rc': RCConfigurationForm,
49 'rc': RCConfigurationForm,
50 'dds': DDSConfigurationForm,
50 'dds': DDSConfigurationForm,
51 'dds_rest': DDSRestConfigurationForm,
51 'dds_rest': DDSRestConfigurationForm,
52 'jars': JARSConfigurationForm,
52 'jars': JARSConfigurationForm,
53 'cgs': CGSConfigurationForm,
53 'cgs': CGSConfigurationForm,
54 'abs': ABSConfigurationForm,
54 'abs': ABSConfigurationForm,
55 'usrp': USRPConfigurationForm,
55 'usrp': USRPConfigurationForm,
56 }
56 }
57
57
58 CONF_MODELS = {
58 CONF_MODELS = {
59 'rc': RCConfiguration,
59 'rc': RCConfiguration,
60 'dds': DDSConfiguration,
60 'dds': DDSConfiguration,
61 'dds_rest': DDSRestConfiguration,
61 'dds_rest': DDSRestConfiguration,
62 'jars': JARSConfiguration,
62 'jars': JARSConfiguration,
63 'cgs': CGSConfiguration,
63 'cgs': CGSConfiguration,
64 'abs': ABSConfiguration,
64 'abs': ABSConfiguration,
65 'usrp': USRPConfiguration,
65 'usrp': USRPConfiguration,
66 }
66 }
67
67
68 MIX_MODES = {
68 MIX_MODES = {
69 '0': 'P',
69 '0': 'P',
70 '1': 'S',
70 '1': 'S',
71 }
71 }
72
72
73 MIX_OPERATIONS = {
73 MIX_OPERATIONS = {
74 '0': 'OR',
74 '0': 'OR',
75 '1': 'XOR',
75 '1': 'XOR',
76 '2': 'AND',
76 '2': 'AND',
77 '3': 'NAND',
77 '3': 'NAND',
78 }
78 }
79
79
80
80
81 def is_developer(user):
81 def is_developer(user):
82
82
83 groups = [str(g.name) for g in user.groups.all()]
83 groups = [str(g.name) for g in user.groups.all()]
84 return 'Developer' in groups or user.is_staff
84 return 'Developer' in groups or user.is_staff
85
85
86
86
87 def is_operator(user):
87 def is_operator(user):
88
88
89 groups = [str(g.name) for g in user.groups.all()]
89 groups = [str(g.name) for g in user.groups.all()]
90 return 'Operator' in groups or user.is_staff
90 return 'Operator' in groups or user.is_staff
91
91
92
92
93 def has_been_modified(model):
93 def has_been_modified(model):
94
94
95 prev_hash = model.hash
95 prev_hash = model.hash
96 new_hash = hashlib.sha256(str(model.parms_to_dict).encode()).hexdigest()
96 new_hash = hashlib.sha256(str(model.parms_to_dict).encode()).hexdigest()
97 if prev_hash != new_hash:
97 if prev_hash != new_hash:
98 model.hash = new_hash
98 model.hash = new_hash
99 model.save()
99 model.save()
100 return True
100 return True
101 return False
101 return False
102
102
103
103
104 def index(request):
104 def index(request):
105 kwargs = {'no_sidebar': True}
105 kwargs = {'no_sidebar': True}
106
106
107 return render(request, 'index.html', kwargs)
107 return render(request, 'index.html', kwargs)
108
108
109
109
110 def locations(request):
110 def locations(request):
111
111
112 page = request.GET.get('page')
112 page = request.GET.get('page')
113 order = ('name',)
113 order = ('name',)
114
114
115 kwargs = get_paginator(Location, page, order)
115 kwargs = get_paginator(Location, page, order)
116
116
117 kwargs['keys'] = ['name', 'description']
117 kwargs['keys'] = ['name', 'description']
118 kwargs['title'] = 'Radar System'
118 kwargs['title'] = 'Radar System'
119 kwargs['suptitle'] = 'List'
119 kwargs['suptitle'] = 'List'
120 kwargs['no_sidebar'] = True
120 kwargs['no_sidebar'] = True
121
121
122 return render(request, 'base_list.html', kwargs)
122 return render(request, 'base_list.html', kwargs)
123
123
124
124
125 def location(request, id_loc):
125 def location(request, id_loc):
126
126
127 location = get_object_or_404(Location, pk=id_loc)
127 location = get_object_or_404(Location, pk=id_loc)
128
128
129 kwargs = {}
129 kwargs = {}
130 kwargs['location'] = location
130 kwargs['location'] = location
131 kwargs['location_keys'] = ['name', 'description']
131 kwargs['location_keys'] = ['name', 'description']
132
132
133 kwargs['title'] = 'Location'
133 kwargs['title'] = 'Location'
134 kwargs['suptitle'] = 'Details'
134 kwargs['suptitle'] = 'Details'
135
135
136 return render(request, 'location.html', kwargs)
136 return render(request, 'location.html', kwargs)
137
137
138
138
139 @login_required
139 @login_required
140 def location_new(request):
140 def location_new(request):
141
141
142 if request.method == 'GET':
142 if request.method == 'GET':
143 form = LocationForm()
143 form = LocationForm()
144
144
145 if request.method == 'POST':
145 if request.method == 'POST':
146 form = LocationForm(request.POST)
146 form = LocationForm(request.POST)
147
147
148 if form.is_valid():
148 if form.is_valid():
149 form.save()
149 form.save()
150 return redirect('url_locations')
150 return redirect('url_locations')
151
151
152 kwargs = {}
152 kwargs = {}
153 kwargs['form'] = form
153 kwargs['form'] = form
154 kwargs['title'] = 'Radar System'
154 kwargs['title'] = 'Radar System'
155 kwargs['suptitle'] = 'New'
155 kwargs['suptitle'] = 'New'
156 kwargs['button'] = 'Create'
156 kwargs['button'] = 'Create'
157
157
158 return render(request, 'base_edit.html', kwargs)
158 return render(request, 'base_edit.html', kwargs)
159
159
160
160
161 @login_required
161 @login_required
162 def location_edit(request, id_loc):
162 def location_edit(request, id_loc):
163
163
164 location = get_object_or_404(Location, pk=id_loc)
164 location = get_object_or_404(Location, pk=id_loc)
165
165
166 if request.method == 'GET':
166 if request.method == 'GET':
167 form = LocationForm(instance=location)
167 form = LocationForm(instance=location)
168
168
169 if request.method == 'POST':
169 if request.method == 'POST':
170 form = LocationForm(request.POST, instance=location)
170 form = LocationForm(request.POST, instance=location)
171
171
172 if form.is_valid():
172 if form.is_valid():
173 form.save()
173 form.save()
174 return redirect('url_locations')
174 return redirect('url_locations')
175
175
176 kwargs = {}
176 kwargs = {}
177 kwargs['form'] = form
177 kwargs['form'] = form
178 kwargs['title'] = 'Location'
178 kwargs['title'] = 'Location'
179 kwargs['suptitle'] = 'Edit'
179 kwargs['suptitle'] = 'Edit'
180 kwargs['button'] = 'Update'
180 kwargs['button'] = 'Update'
181
181
182 return render(request, 'base_edit.html', kwargs)
182 return render(request, 'base_edit.html', kwargs)
183
183
184
184
185 @login_required
185 @login_required
186 def location_delete(request, id_loc):
186 def location_delete(request, id_loc):
187
187
188 location = get_object_or_404(Location, pk=id_loc)
188 location = get_object_or_404(Location, pk=id_loc)
189
189
190 if request.method == 'POST':
190 if request.method == 'POST':
191
191
192 if is_developer(request.user):
192 if is_developer(request.user):
193 location.delete()
193 location.delete()
194 return redirect('url_locations')
194 return redirect('url_locations')
195
195
196 messages.error(request, 'Not enough permission to delete this object')
196 messages.error(request, 'Not enough permission to delete this object')
197 return redirect(location.get_absolute_url())
197 return redirect(location.get_absolute_url())
198
198
199 kwargs = {
199 kwargs = {
200 'title': 'Delete',
200 'title': 'Delete',
201 'suptitle': 'Location',
201 'suptitle': 'Location',
202 'object': location,
202 'object': location,
203 'delete': True
203 'delete': True
204 }
204 }
205
205
206 return render(request, 'confirm.html', kwargs)
206 return render(request, 'confirm.html', kwargs)
207
207
208
208
209 def devices(request):
209 def devices(request):
210
210
211 page = request.GET.get('page')
211 page = request.GET.get('page')
212 order = ('location', 'device_type')
212 order = ('location', 'device_type')
213
213
214 filters = request.GET.copy()
214 filters = request.GET.copy()
215 kwargs = get_paginator(Device, page, order, filters)
215 kwargs = get_paginator(Device, page, order, filters)
216 form = FilterForm(initial=request.GET, extra_fields=['tags'])
216 form = FilterForm(initial=request.GET, extra_fields=['tags'])
217
217
218 kwargs['keys'] = ['device_type', 'location',
218 kwargs['keys'] = ['device_type', 'location',
219 'ip_address', 'port_address', 'actions']
219 'ip_address', 'port_address', 'actions']
220 kwargs['title'] = 'Device'
220 kwargs['title'] = 'Device'
221 kwargs['suptitle'] = 'List'
221 kwargs['suptitle'] = 'List'
222 kwargs['no_sidebar'] = True
222 kwargs['no_sidebar'] = True
223 kwargs['form'] = form
223 kwargs['form'] = form
224 kwargs['add_url'] = reverse('url_add_device')
224 kwargs['add_url'] = reverse('url_add_device')
225 filters.pop('page', None)
225 filters.pop('page', None)
226 kwargs['q'] = urlencode(filters)
226 kwargs['q'] = urlencode(filters)
227 kwargs['menu_devices'] = 'active'
227 kwargs['menu_devices'] = 'active'
228 return render(request, 'base_list.html', kwargs)
228 return render(request, 'base_list.html', kwargs)
229
229
230
230
231 def device(request, id_dev):
231 def device(request, id_dev):
232
232
233 device = get_object_or_404(Device, pk=id_dev)
233 device = get_object_or_404(Device, pk=id_dev)
234
234
235 kwargs = {}
235 kwargs = {}
236 kwargs['device'] = device
236 kwargs['device'] = device
237 kwargs['device_keys'] = ['device_type',
237 kwargs['device_keys'] = ['device_type',
238 'ip_address', 'port_address', 'description']
238 'ip_address', 'port_address', 'description']
239
239
240 kwargs['title'] = 'Device'
240 kwargs['title'] = 'Device'
241 kwargs['suptitle'] = 'Details'
241 kwargs['suptitle'] = 'Details'
242 kwargs['menu_devices'] = 'active'
242 kwargs['menu_devices'] = 'active'
243
243
244 return render(request, 'device.html', kwargs)
244 return render(request, 'device.html', kwargs)
245
245
246
246
247 @login_required
247 @login_required
248 def device_new(request):
248 def device_new(request):
249
249
250 if request.method == 'GET':
250 if request.method == 'GET':
251 form = DeviceForm()
251 form = DeviceForm()
252
252
253 if request.method == 'POST':
253 if request.method == 'POST':
254 form = DeviceForm(request.POST)
254 form = DeviceForm(request.POST)
255
255
256 if form.is_valid():
256 if form.is_valid():
257 form.save()
257 form.save()
258 return redirect('url_devices')
258 return redirect('url_devices')
259
259
260 kwargs = {}
260 kwargs = {}
261 kwargs['form'] = form
261 kwargs['form'] = form
262 kwargs['title'] = 'Device'
262 kwargs['title'] = 'Device'
263 kwargs['suptitle'] = 'New_2'
263 kwargs['suptitle'] = 'New_2'
264 kwargs['button'] = 'Create'
264 kwargs['button'] = 'Create'
265 kwargs['menu_devices'] = 'active'
265 kwargs['menu_devices'] = 'active'
266
266
267 return render(request, 'base_edit.html', kwargs)
267 return render(request, 'base_edit.html', kwargs)
268
268
269
269
270 @login_required
270 @login_required
271 def device_edit(request, id_dev):
271 def device_edit(request, id_dev):
272
272
273 device = get_object_or_404(Device, pk=id_dev)
273 device = get_object_or_404(Device, pk=id_dev)
274
274
275 if request.method == 'GET':
275 if request.method == 'GET':
276 form = DeviceForm(instance=device)
276 form = DeviceForm(instance=device)
277
277
278 if request.method == 'POST':
278 if request.method == 'POST':
279 form = DeviceForm(request.POST, instance=device)
279 form = DeviceForm(request.POST, instance=device)
280
280
281 if form.is_valid():
281 if form.is_valid():
282 form.save()
282 form.save()
283 return redirect(device.get_absolute_url())
283 return redirect(device.get_absolute_url())
284
284
285 kwargs = {}
285 kwargs = {}
286 kwargs['form'] = form
286 kwargs['form'] = form
287 kwargs['title'] = 'Device'
287 kwargs['title'] = 'Device'
288 kwargs['suptitle'] = 'Edit'
288 kwargs['suptitle'] = 'Edit'
289 kwargs['button'] = 'Update'
289 kwargs['button'] = 'Update'
290 kwargs['menu_devices'] = 'active'
290 kwargs['menu_devices'] = 'active'
291
291
292 return render(request, 'base_edit.html', kwargs)
292 return render(request, 'base_edit.html', kwargs)
293
293
294
294
295 @login_required
295 @login_required
296 def device_delete(request, id_dev):
296 def device_delete(request, id_dev):
297
297
298 device = get_object_or_404(Device, pk=id_dev)
298 device = get_object_or_404(Device, pk=id_dev)
299
299
300 if request.method == 'POST':
300 if request.method == 'POST':
301
301
302 if is_developer(request.user):
302 if is_developer(request.user):
303 device.delete()
303 device.delete()
304 return redirect('url_devices')
304 return redirect('url_devices')
305
305
306 messages.error(request, 'Not enough permission to delete this object')
306 messages.error(request, 'Not enough permission to delete this object')
307 return redirect(device.get_absolute_url())
307 return redirect(device.get_absolute_url())
308
308
309 kwargs = {
309 kwargs = {
310 'title': 'Delete',
310 'title': 'Delete',
311 'suptitle': 'Device',
311 'suptitle': 'Device',
312 'object': device,
312 'object': device,
313 'delete': True
313 'delete': True
314 }
314 }
315 kwargs['menu_devices'] = 'active'
315 kwargs['menu_devices'] = 'active'
316
316
317 return render(request, 'confirm.html', kwargs)
317 return render(request, 'confirm.html', kwargs)
318
318
319
319
320 @login_required
320 @login_required
321 def device_change_ip(request, id_dev):
321 def device_change_ip(request, id_dev):
322
322
323 device = get_object_or_404(Device, pk=id_dev)
323 device = get_object_or_404(Device, pk=id_dev)
324
324
325 if request.method == 'POST':
325 if request.method == 'POST':
326
326
327 if is_developer(request.user):
327 if is_developer(request.user):
328 device.change_ip(**request.POST.dict())
328 device.change_ip(**request.POST.dict())
329
329
330 print(device.ip_address, device.message)
330 print(device.ip_address, device.message)
331
331
332 level, message = device.message.split('|')
332 level, message = device.message.split('|')
333 messages.add_message(request, level, message)
333 messages.add_message(request, level, message)
334 else:
334 else:
335 messages.error(
335 messages.error(
336 request, 'Not enough permission to delete this object')
336 request, 'Not enough permission to delete this object')
337 return redirect(device.get_absolute_url())
337 return redirect(device.get_absolute_url())
338
338
339 kwargs = {
339 kwargs = {
340 'title': 'Device',
340 'title': 'Device',
341 'suptitle': 'Change IP',
341 'suptitle': 'Change IP',
342 'object': device,
342 'object': device,
343 'previous': device.get_absolute_url(),
343 'previous': device.get_absolute_url(),
344 'form': ChangeIpForm(initial={'ip_address': device.ip_address}),
344 'form': ChangeIpForm(initial={'ip_address': device.ip_address}),
345 'message': ' ',
345 'message': ' ',
346 }
346 }
347 kwargs['menu_devices'] = 'active'
347 kwargs['menu_devices'] = 'active'
348
348
349 return render(request, 'confirm.html', kwargs)
349 return render(request, 'confirm.html', kwargs)
350
350
351
351
352 def campaigns(request):
352 def campaigns(request):
353
353
354 page = request.GET.get('page')
354 page = request.GET.get('page')
355 order = ('-start_date',)
355 order = ('-start_date',)
356 filters = request.GET.copy()
356 filters = request.GET.copy()
357
357
358 kwargs = get_paginator(Campaign, page, order, filters)
358 kwargs = get_paginator(Campaign, page, order, filters)
359
359
360 form = FilterForm(initial=request.GET, extra_fields=[
360 form = FilterForm(initial=request.GET, extra_fields=[
361 'range_date', 'tags', 'template'])
361 'range_date', 'tags', 'template'])
362 kwargs['keys'] = ['name', 'start_date', 'end_date', 'actions']
362 kwargs['keys'] = ['name', 'start_date', 'end_date', 'actions']
363 kwargs['title'] = 'Campaign'
363 kwargs['title'] = 'Campaign'
364 kwargs['suptitle'] = 'List'
364 kwargs['suptitle'] = 'List'
365 kwargs['no_sidebar'] = True
365 kwargs['no_sidebar'] = True
366 kwargs['form'] = form
366 kwargs['form'] = form
367 kwargs['add_url'] = reverse('url_add_campaign')
367 kwargs['add_url'] = reverse('url_add_campaign')
368 filters.pop('page', None)
368 filters.pop('page', None)
369 kwargs['q'] = urlencode(filters)
369 kwargs['q'] = urlencode(filters)
370 kwargs['menu_campaigns'] = 'active'
370 kwargs['menu_campaigns'] = 'active'
371
371
372 return render(request, 'base_list.html', kwargs)
372 return render(request, 'base_list.html', kwargs)
373
373
374
374
375 def campaign(request, id_camp):
375 def campaign(request, id_camp):
376
376
377 campaign = get_object_or_404(Campaign, pk=id_camp)
377 campaign = get_object_or_404(Campaign, pk=id_camp)
378 experiments = Experiment.objects.filter(campaign=campaign)
378 experiments = Experiment.objects.filter(campaign=campaign)
379
379
380 form = CampaignForm(instance=campaign)
380 form = CampaignForm(instance=campaign)
381
381
382 kwargs = {}
382 kwargs = {}
383 kwargs['campaign'] = campaign
383 kwargs['campaign'] = campaign
384 kwargs['campaign_keys'] = ['template', 'name',
384 kwargs['campaign_keys'] = ['template', 'name',
385 'start_date', 'end_date', 'tags', 'description']
385 'start_date', 'end_date', 'tags', 'description']
386
386
387 kwargs['experiments'] = experiments
387 kwargs['experiments'] = experiments
388 kwargs['experiment_keys'] = [
388 kwargs['experiment_keys'] = [
389 'name', 'radar_system', 'start_time', 'end_time']
389 'name', 'radar_system', 'start_time', 'end_time']
390
390
391 kwargs['title'] = 'Campaign'
391 kwargs['title'] = 'Campaign'
392 kwargs['suptitle'] = 'Details'
392 kwargs['suptitle'] = 'Details'
393
393
394 kwargs['form'] = form
394 kwargs['form'] = form
395 kwargs['button'] = 'Add Experiment'
395 kwargs['button'] = 'Add Experiment'
396 kwargs['menu_campaigns'] = 'active'
396 kwargs['menu_campaigns'] = 'active'
397
397
398 return render(request, 'campaign.html', kwargs)
398 return render(request, 'campaign.html', kwargs)
399
399
400
400
401 @login_required
401 @login_required
402 def campaign_new(request):
402 def campaign_new(request):
403
403
404 kwargs = {}
404 kwargs = {}
405
405
406 if request.method == 'GET':
406 if request.method == 'GET':
407
407
408 if 'template' in request.GET:
408 if 'template' in request.GET:
409 if request.GET['template'] == '0':
409 if request.GET['template'] == '0':
410 form = NewForm(initial={'create_from': 2},
410 form = NewForm(initial={'create_from': 2},
411 template_choices=Campaign.objects.filter(template=True).values_list('id', 'name'))
411 template_choices=Campaign.objects.filter(template=True).values_list('id', 'name'))
412 else:
412 else:
413 kwargs['button'] = 'Create'
413 kwargs['button'] = 'Create'
414 kwargs['experiments'] = Configuration.objects.filter(
414 kwargs['experiments'] = Configuration.objects.filter(
415 experiment=request.GET['template'])
415 experiment=request.GET['template'])
416 kwargs['experiment_keys'] = ['name', 'start_time', 'end_time']
416 kwargs['experiment_keys'] = ['name', 'start_time', 'end_time']
417 camp = Campaign.objects.get(pk=request.GET['template'])
417 camp = Campaign.objects.get(pk=request.GET['template'])
418 form = CampaignForm(instance=camp,
418 form = CampaignForm(instance=camp,
419 initial={'name': '{}_{:%Y%m%d}'.format(camp.name, datetime.now()),
419 initial={'name': '{}_{:%Y%m%d%H%M%S}'.format(camp.name, datetime.now()),
420 'template': False})
420 'template': False})
421 elif 'blank' in request.GET:
421 elif 'blank' in request.GET:
422 kwargs['button'] = 'Create'
422 kwargs['button'] = 'Create'
423 form = CampaignForm()
423 form = CampaignForm()
424 else:
424 else:
425 form = NewForm()
425 form = NewForm()
426
426
427 if request.method == 'POST':
427 if request.method == 'POST':
428 kwargs['button'] = 'Create'
428 kwargs['button'] = 'Create'
429 post = request.POST.copy()
429 post = request.POST.copy()
430 experiments = []
430 experiments = []
431
431
432 for id_exp in post.getlist('experiments'):
432 for id_exp in post.getlist('experiments'):
433 exp = Experiment.objects.get(pk=id_exp)
433 exp = Experiment.objects.get(pk=id_exp)
434 new_exp = exp.clone(template=False)
434 new_exp = exp.clone(template=False)
435 experiments.append(new_exp)
435 experiments.append(new_exp)
436
436
437 post.setlist('experiments', [])
437 post.setlist('experiments', [])
438
438
439 form = CampaignForm(post)
439 form = CampaignForm(post)
440
440
441 if form.is_valid():
441 if form.is_valid():
442 campaign = form.save(commit=False)
442 campaign = form.save(commit=False)
443 campaign.author = request.user
443 campaign.author = request.user
444 campaign.save()
444 campaign.save()
445 for exp in experiments:
445 for exp in experiments:
446 campaign.experiments.add(exp)
446 campaign.experiments.add(exp)
447
447
448 return redirect('url_campaign', id_camp=campaign.id)
448 return redirect('url_campaign', id_camp=campaign.id)
449
449
450 kwargs['form'] = form
450 kwargs['form'] = form
451 kwargs['title'] = 'Campaign'
451 kwargs['title'] = 'Campaign'
452 kwargs['suptitle'] = 'New'
452 kwargs['suptitle'] = 'New'
453 kwargs['menu_campaigns'] = 'active'
453 kwargs['menu_campaigns'] = 'active'
454
454
455 return render(request, 'campaign_edit.html', kwargs)
455 return render(request, 'campaign_edit.html', kwargs)
456
456
457
457
458 @login_required
458 @login_required
459 def campaign_edit(request, id_camp):
459 def campaign_edit(request, id_camp):
460
460
461 campaign = get_object_or_404(Campaign, pk=id_camp)
461 campaign = get_object_or_404(Campaign, pk=id_camp)
462
462
463 if request.method == 'GET':
463 if request.method == 'GET':
464 form = CampaignForm(instance=campaign)
464 form = CampaignForm(instance=campaign)
465
465
466 if request.method == 'POST':
466 if request.method == 'POST':
467 exps = campaign.experiments.all().values_list('pk', flat=True)
467 exps = campaign.experiments.all().values_list('pk', flat=True)
468 post = request.POST.copy()
468 post = request.POST.copy()
469 new_exps = post.getlist('experiments')
469 new_exps = post.getlist('experiments')
470 post.setlist('experiments', [])
470 post.setlist('experiments', [])
471 form = CampaignForm(post, instance=campaign)
471 form = CampaignForm(post, instance=campaign)
472
472
473 if form.is_valid():
473 if form.is_valid():
474 camp = form.save()
474 camp = form.save()
475 for id_exp in new_exps:
475 for id_exp in new_exps:
476 if int(id_exp) in exps:
476 if int(id_exp) in exps:
477 exps.pop(id_exp)
477 exps.pop(id_exp)
478 else:
478 else:
479 exp = Experiment.objects.get(pk=id_exp)
479 exp = Experiment.objects.get(pk=id_exp)
480 if exp.template:
480 if exp.template:
481 camp.experiments.add(exp.clone(template=False))
481 camp.experiments.add(exp.clone(template=False))
482 else:
482 else:
483 camp.experiments.add(exp)
483 camp.experiments.add(exp)
484
484
485 for id_exp in exps:
485 for id_exp in exps:
486 camp.experiments.remove(Experiment.objects.get(pk=id_exp))
486 camp.experiments.remove(Experiment.objects.get(pk=id_exp))
487
487
488 return redirect('url_campaign', id_camp=id_camp)
488 return redirect('url_campaign', id_camp=id_camp)
489
489
490 kwargs = {}
490 kwargs = {}
491 kwargs['form'] = form
491 kwargs['form'] = form
492 kwargs['title'] = 'Campaign'
492 kwargs['title'] = 'Campaign'
493 kwargs['suptitle'] = 'Edit'
493 kwargs['suptitle'] = 'Edit'
494 kwargs['button'] = 'Update'
494 kwargs['button'] = 'Update'
495 kwargs['menu_campaigns'] = 'active'
495 kwargs['menu_campaigns'] = 'active'
496
496
497 return render(request, 'campaign_edit.html', kwargs)
497 return render(request, 'campaign_edit.html', kwargs)
498
498
499
499
500 @login_required
500 @login_required
501 def campaign_delete(request, id_camp):
501 def campaign_delete(request, id_camp):
502
502
503 campaign = get_object_or_404(Campaign, pk=id_camp)
503 campaign = get_object_or_404(Campaign, pk=id_camp)
504
504
505 if request.method == 'POST':
505 if request.method == 'POST':
506 if is_developer(request.user):
506 if is_developer(request.user):
507
507
508 for exp in campaign.experiments.all():
508 for exp in campaign.experiments.all():
509 for conf in Configuration.objects.filter(experiment=exp):
509 for conf in Configuration.objects.filter(experiment=exp):
510 conf.delete()
510 conf.delete()
511 exp.delete()
511 exp.delete()
512 campaign.delete()
512 campaign.delete()
513
513
514 return redirect('url_campaigns')
514 return redirect('url_campaigns')
515
515
516 messages.error(request, 'Not enough permission to delete this object')
516 messages.error(request, 'Not enough permission to delete this object')
517 return redirect(campaign.get_absolute_url())
517 return redirect(campaign.get_absolute_url())
518
518
519 kwargs = {
519 kwargs = {
520 'title': 'Delete',
520 'title': 'Delete',
521 'suptitle': 'Campaign',
521 'suptitle': 'Campaign',
522 'object': campaign,
522 'object': campaign,
523 'delete': True
523 'delete': True
524 }
524 }
525 kwargs['menu_campaigns'] = 'active'
525 kwargs['menu_campaigns'] = 'active'
526
526
527 return render(request, 'confirm.html', kwargs)
527 return render(request, 'confirm.html', kwargs)
528
528
529
529
530 @login_required
530 @login_required
531 def campaign_export(request, id_camp):
531 def campaign_export(request, id_camp):
532
532
533 campaign = get_object_or_404(Campaign, pk=id_camp)
533 campaign = get_object_or_404(Campaign, pk=id_camp)
534 content = campaign.parms_to_dict()
534 content = campaign.parms_to_dict()
535 content_type = 'application/json'
535 content_type = 'application/json'
536 filename = '%s_%s.json' % (campaign.name, campaign.id)
536 filename = '%s_%s.json' % (campaign.name, campaign.id)
537
537
538 response = HttpResponse(content_type=content_type)
538 response = HttpResponse(content_type=content_type)
539 response['Content-Disposition'] = 'attachment; filename="%s"' % filename
539 response['Content-Disposition'] = 'attachment; filename="%s"' % filename
540 response.write(json.dumps(content, indent=2))
540 response.write(json.dumps(content, indent=2))
541
541
542 return response
542 return response
543
543
544
544
545 @login_required
545 @login_required
546 def campaign_import(request, id_camp):
546 def campaign_import(request, id_camp):
547
547
548 campaign = get_object_or_404(Campaign, pk=id_camp)
548 campaign = get_object_or_404(Campaign, pk=id_camp)
549
549
550 if request.method == 'GET':
550 if request.method == 'GET':
551 file_form = UploadFileForm()
551 file_form = UploadFileForm()
552
552
553 if request.method == 'POST':
553 if request.method == 'POST':
554 file_form = UploadFileForm(request.POST, request.FILES)
554 file_form = UploadFileForm(request.POST, request.FILES)
555
555
556 if file_form.is_valid():
556 if file_form.is_valid():
557 new_camp = campaign.dict_to_parms(
557 new_camp = campaign.dict_to_parms(
558 json.load(request.FILES['file']), CONF_MODELS)
558 json.load(request.FILES['file']), CONF_MODELS)
559 messages.success(
559 messages.success(
560 request, "Parameters imported from: '%s'." % request.FILES['file'].name)
560 request, "Parameters imported from: '%s'." % request.FILES['file'].name)
561 return redirect(new_camp.get_absolute_url_edit())
561 return redirect(new_camp.get_absolute_url_edit())
562
562
563 messages.error(request, "Could not import parameters from file")
563 messages.error(request, "Could not import parameters from file")
564
564
565 kwargs = {}
565 kwargs = {}
566 kwargs['title'] = 'Campaign'
566 kwargs['title'] = 'Campaign'
567 kwargs['form'] = file_form
567 kwargs['form'] = file_form
568 kwargs['suptitle'] = 'Importing file'
568 kwargs['suptitle'] = 'Importing file'
569 kwargs['button'] = 'Import'
569 kwargs['button'] = 'Import'
570 kwargs['menu_campaigns'] = 'active'
570 kwargs['menu_campaigns'] = 'active'
571
571
572 return render(request, 'campaign_import.html', kwargs)
572 return render(request, 'campaign_import.html', kwargs)
573
573
574
574
575 def experiments(request):
575 def experiments(request):
576
576
577 page = request.GET.get('page')
577 page = request.GET.get('page')
578 order = ('location',)
578 order = ('location',)
579 filters = request.GET.copy()
579 filters = request.GET.copy()
580
580
581 if 'my experiments' in filters:
581 if 'my experiments' in filters:
582 filters.pop('my experiments', None)
582 filters.pop('my experiments', None)
583 filters['mine'] = request.user.id
583 filters['mine'] = request.user.id
584
584
585 kwargs = get_paginator(Experiment, page, order, filters)
585 kwargs = get_paginator(Experiment, page, order, filters)
586
586
587 fields = ['tags', 'template']
587 fields = ['tags', 'template']
588 if request.user.is_authenticated:
588 if request.user.is_authenticated:
589 fields.append('my experiments')
589 fields.append('my experiments')
590
590
591 form = FilterForm(initial=request.GET, extra_fields=fields)
591 form = FilterForm(initial=request.GET, extra_fields=fields)
592
592
593 kwargs['keys'] = ['name', 'radar_system',
593 kwargs['keys'] = ['name', 'radar_system',
594 'start_time', 'end_time', 'actions']
594 'start_time', 'end_time', 'actions']
595 kwargs['title'] = 'Experiment'
595 kwargs['title'] = 'Experiment'
596 kwargs['suptitle'] = 'List'
596 kwargs['suptitle'] = 'List'
597 kwargs['no_sidebar'] = True
597 kwargs['no_sidebar'] = True
598 kwargs['form'] = form
598 kwargs['form'] = form
599 kwargs['add_url'] = reverse('url_add_experiment')
599 kwargs['add_url'] = reverse('url_add_experiment')
600 filters = request.GET.copy()
600 filters = request.GET.copy()
601 filters.pop('page', None)
601 filters.pop('page', None)
602 kwargs['q'] = urlencode(filters)
602 kwargs['q'] = urlencode(filters)
603 kwargs['menu_experiments'] = 'active'
603 kwargs['menu_experiments'] = 'active'
604
604
605 return render(request, 'base_list.html', kwargs)
605 return render(request, 'base_list.html', kwargs)
606
606
607
607
608 def experiment(request, id_exp):
608 def experiment(request, id_exp):
609
609
610 experiment = get_object_or_404(Experiment, pk=id_exp)
610 experiment = get_object_or_404(Experiment, pk=id_exp)
611
611
612 configurations = Configuration.objects.filter(
612 configurations = Configuration.objects.filter(
613 experiment=experiment, type=0)
613 experiment=experiment, type=0)
614
614
615 kwargs = {}
615 kwargs = {}
616
616
617 kwargs['experiment_keys'] = ['template', 'radar_system',
617 kwargs['experiment_keys'] = ['template', 'radar_system',
618 'name', 'freq', 'start_time', 'end_time']
618 'name', 'freq', 'start_time', 'end_time']
619 kwargs['experiment'] = experiment
619 kwargs['experiment'] = experiment
620 kwargs['configuration_keys'] = ['name', 'device__ip_address',
620 kwargs['configuration_keys'] = ['name', 'device__ip_address',
621 'device__port_address', 'device__status']
621 'device__port_address', 'device__status']
622 kwargs['configurations'] = configurations
622 kwargs['configurations'] = configurations
623 kwargs['title'] = 'Experiment'
623 kwargs['title'] = 'Experiment'
624 kwargs['suptitle'] = 'Details'
624 kwargs['suptitle'] = 'Details'
625 kwargs['button'] = 'Add Configuration'
625 kwargs['button'] = 'Add Configuration'
626 kwargs['menu_experiments'] = 'active'
626 kwargs['menu_experiments'] = 'active'
627
627
628 ###### SIDEBAR ######
628 ###### SIDEBAR ######
629 kwargs.update(sidebar(experiment=experiment))
629 kwargs.update(sidebar(experiment=experiment))
630
630
631 return render(request, 'experiment.html', kwargs)
631 return render(request, 'experiment.html', kwargs)
632
632
633
633
634 @login_required
634 @login_required
635 def experiment_new(request, id_camp=None):
635 def experiment_new(request, id_camp=None):
636
636
637 if not is_developer(request.user):
637 if not is_developer(request.user):
638 messages.error(
638 messages.error(
639 request, 'Developer required, to create new Experiments')
639 request, 'Developer required, to create new Experiments')
640 return redirect('index')
640 return redirect('index')
641 kwargs = {}
641 kwargs = {}
642
642
643 if request.method == 'GET':
643 if request.method == 'GET':
644 if 'template' in request.GET:
644 if 'template' in request.GET:
645 if request.GET['template'] == '0':
645 if request.GET['template'] == '0':
646 form = NewForm(initial={'create_from': 2},
646 form = NewForm(initial={'create_from': 2},
647 template_choices=Experiment.objects.filter(template=True).values_list('id', 'name'))
647 template_choices=Experiment.objects.filter(template=True).values_list('id', 'name'))
648 else:
648 else:
649 kwargs['button'] = 'Create'
649 kwargs['button'] = 'Create'
650 kwargs['configurations'] = Configuration.objects.filter(
650 kwargs['configurations'] = Configuration.objects.filter(
651 experiment=request.GET['template'])
651 experiment=request.GET['template'])
652 kwargs['configuration_keys'] = ['name', 'device__name',
652 kwargs['configuration_keys'] = ['name', 'device__name',
653 'device__ip_address', 'device__port_address']
653 'device__ip_address', 'device__port_address']
654 exp = Experiment.objects.get(pk=request.GET['template'])
654 exp = Experiment.objects.get(pk=request.GET['template'])
655 form = ExperimentForm(instance=exp,
655 form = ExperimentForm(instance=exp,
656 initial={'name': '{}_{:%y%m%d}'.format(exp.name, datetime.now()),
656 initial={'name': '{}_{:%y%m%d}'.format(exp.name, datetime.now()),
657 'template': False})
657 'template': False})
658 elif 'blank' in request.GET:
658 elif 'blank' in request.GET:
659 kwargs['button'] = 'Create'
659 kwargs['button'] = 'Create'
660 form = ExperimentForm()
660 form = ExperimentForm()
661 else:
661 else:
662 form = NewForm()
662 form = NewForm()
663
663
664 if request.method == 'POST':
664 if request.method == 'POST':
665 form = ExperimentForm(request.POST)
665 form = ExperimentForm(request.POST)
666 if form.is_valid():
666 if form.is_valid():
667 experiment = form.save(commit=False)
667 experiment = form.save(commit=False)
668 experiment.author = request.user
668 experiment.author = request.user
669 experiment.save()
669 experiment.save()
670
670
671 if 'template' in request.GET:
671 if 'template' in request.GET:
672 configurations = Configuration.objects.filter(
672 configurations = Configuration.objects.filter(
673 experiment=request.GET['template'], type=0)
673 experiment=request.GET['template'], type=0)
674 for conf in configurations:
674 for conf in configurations:
675 conf.clone(experiment=experiment, template=False)
675 conf.clone(experiment=experiment, template=False)
676
676
677 return redirect('url_experiment', id_exp=experiment.id)
677 return redirect('url_experiment', id_exp=experiment.id)
678
678
679 kwargs['form'] = form
679 kwargs['form'] = form
680 kwargs['title'] = 'Experiment'
680 kwargs['title'] = 'Experiment'
681 kwargs['suptitle'] = 'New'
681 kwargs['suptitle'] = 'New'
682 kwargs['menu_experiments'] = 'active'
682 kwargs['menu_experiments'] = 'active'
683
683
684 return render(request, 'experiment_edit.html', kwargs)
684 return render(request, 'experiment_edit.html', kwargs)
685
685
686
686
687 @login_required
687 @login_required
688 def experiment_edit(request, id_exp):
688 def experiment_edit(request, id_exp):
689
689
690 experiment = get_object_or_404(Experiment, pk=id_exp)
690 experiment = get_object_or_404(Experiment, pk=id_exp)
691
691
692 if request.method == 'GET':
692 if request.method == 'GET':
693 form = ExperimentForm(instance=experiment)
693 form = ExperimentForm(instance=experiment)
694
694
695 if request.method == 'POST':
695 if request.method == 'POST':
696 form = ExperimentForm(request.POST, instance=experiment)
696 form = ExperimentForm(request.POST, instance=experiment)
697
697
698 if form.is_valid():
698 if form.is_valid():
699 experiment = form.save()
699 experiment = form.save()
700 return redirect('url_experiment', id_exp=experiment.id)
700 return redirect('url_experiment', id_exp=experiment.id)
701
701
702 kwargs = {}
702 kwargs = {}
703 kwargs['form'] = form
703 kwargs['form'] = form
704 kwargs['title'] = 'Experiment'
704 kwargs['title'] = 'Experiment'
705 kwargs['suptitle'] = 'Edit'
705 kwargs['suptitle'] = 'Edit'
706 kwargs['button'] = 'Update'
706 kwargs['button'] = 'Update'
707 kwargs['menu_experiments'] = 'active'
707 kwargs['menu_experiments'] = 'active'
708
708
709 return render(request, 'experiment_edit.html', kwargs)
709 return render(request, 'experiment_edit.html', kwargs)
710
710
711
711
712 @login_required
712 @login_required
713 def experiment_delete(request, id_exp):
713 def experiment_delete(request, id_exp):
714
714
715 experiment = get_object_or_404(Experiment, pk=id_exp)
715 experiment = get_object_or_404(Experiment, pk=id_exp)
716
716
717 if request.method == 'POST':
717 if request.method == 'POST':
718 if is_developer(request.user):
718 if is_developer(request.user):
719 for conf in Configuration.objects.filter(experiment=experiment):
719 for conf in Configuration.objects.filter(experiment=experiment):
720 conf.delete()
720 conf.delete()
721 experiment.delete()
721 experiment.delete()
722 return redirect('url_experiments')
722 return redirect('url_experiments')
723
723
724 messages.error(request, 'Not enough permission to delete this object')
724 messages.error(request, 'Not enough permission to delete this object')
725 return redirect(experiment.get_absolute_url())
725 return redirect(experiment.get_absolute_url())
726
726
727 kwargs = {
727 kwargs = {
728 'title': 'Delete',
728 'title': 'Delete',
729 'suptitle': 'Experiment',
729 'suptitle': 'Experiment',
730 'object': experiment,
730 'object': experiment,
731 'delete': True
731 'delete': True
732 }
732 }
733
733
734 return render(request, 'confirm.html', kwargs)
734 return render(request, 'confirm.html', kwargs)
735
735
736
736
737 @login_required
737 @login_required
738 def experiment_export(request, id_exp):
738 def experiment_export(request, id_exp):
739
739
740 experiment = get_object_or_404(Experiment, pk=id_exp)
740 experiment = get_object_or_404(Experiment, pk=id_exp)
741 content = experiment.parms_to_dict()
741 content = experiment.parms_to_dict()
742 content_type = 'application/json'
742 content_type = 'application/json'
743 filename = '%s_%s.json' % (experiment.name, experiment.id)
743 filename = '%s_%s.json' % (experiment.name, experiment.id)
744
744
745 response = HttpResponse(content_type=content_type)
745 response = HttpResponse(content_type=content_type)
746 response['Content-Disposition'] = 'attachment; filename="%s"' % filename
746 response['Content-Disposition'] = 'attachment; filename="%s"' % filename
747 response.write(json.dumps(content, indent=2))
747 response.write(json.dumps(content, indent=2))
748
748
749 return response
749 return response
750
750
751
751
752 @login_required
752 @login_required
753 def experiment_import(request, id_exp):
753 def experiment_import(request, id_exp):
754
754
755 experiment = get_object_or_404(Experiment, pk=id_exp)
755 experiment = get_object_or_404(Experiment, pk=id_exp)
756 configurations = Configuration.objects.filter(experiment=experiment)
756 configurations = Configuration.objects.filter(experiment=experiment)
757
757
758 if request.method == 'GET':
758 if request.method == 'GET':
759 file_form = UploadFileForm()
759 file_form = UploadFileForm()
760
760
761 if request.method == 'POST':
761 if request.method == 'POST':
762 file_form = UploadFileForm(request.POST, request.FILES)
762 file_form = UploadFileForm(request.POST, request.FILES)
763
763
764 if file_form.is_valid():
764 if file_form.is_valid():
765 new_exp = experiment.dict_to_parms(
765 new_exp = experiment.dict_to_parms(
766 json.load(request.FILES['file']), CONF_MODELS)
766 json.load(request.FILES['file']), CONF_MODELS)
767 messages.success(
767 messages.success(
768 request, "Parameters imported from: '%s'." % request.FILES['file'].name)
768 request, "Parameters imported from: '%s'." % request.FILES['file'].name)
769 return redirect(new_exp.get_absolute_url_edit())
769 return redirect(new_exp.get_absolute_url_edit())
770
770
771 messages.error(request, "Could not import parameters from file")
771 messages.error(request, "Could not import parameters from file")
772
772
773 kwargs = {}
773 kwargs = {}
774 kwargs['title'] = 'Experiment'
774 kwargs['title'] = 'Experiment'
775 kwargs['form'] = file_form
775 kwargs['form'] = file_form
776 kwargs['suptitle'] = 'Importing file'
776 kwargs['suptitle'] = 'Importing file'
777 kwargs['button'] = 'Import'
777 kwargs['button'] = 'Import'
778 kwargs['menu_experiments'] = 'active'
778 kwargs['menu_experiments'] = 'active'
779
779
780 kwargs.update(sidebar(experiment=experiment))
780 kwargs.update(sidebar(experiment=experiment))
781
781
782 return render(request, 'experiment_import.html', kwargs)
782 return render(request, 'experiment_import.html', kwargs)
783
783
784
784
785 @login_required
785 @login_required
786 def experiment_start(request, id_exp):
786 def experiment_start(request, id_exp):
787
787
788 exp = get_object_or_404(Experiment, pk=id_exp)
788 exp = get_object_or_404(Experiment, pk=id_exp)
789
789
790 if exp.status == 2:
790 if exp.status == 2:
791 messages.warning(request, 'Experiment {} already runnnig'.format(exp))
791 messages.warning(request, 'Experiment {} already runnnig'.format(exp))
792 else:
792 else:
793 exp.status = exp.start()
793 exp.status = exp.start()
794 if exp.status == 0:
794 if exp.status == 0:
795 messages.error(request, 'Experiment {} not start'.format(exp))
795 messages.error(request, 'Experiment {} not start'.format(exp))
796 if exp.status == 2:
796 if exp.status == 2:
797 messages.success(request, 'Experiment {} started'.format(exp))
797 messages.success(request, 'Experiment {} started'.format(exp))
798
798
799 exp.save()
799 exp.save()
800
800
801 return redirect(exp.get_absolute_url())
801 return redirect(exp.get_absolute_url())
802
802
803
803
804 @login_required
804 @login_required
805 def experiment_stop(request, id_exp):
805 def experiment_stop(request, id_exp):
806
806
807 exp = get_object_or_404(Experiment, pk=id_exp)
807 exp = get_object_or_404(Experiment, pk=id_exp)
808
808
809 if exp.status == 2:
809 if exp.status == 2:
810 exp.status = exp.stop()
810 exp.status = exp.stop()
811 exp.save()
811 exp.save()
812 messages.success(request, 'Experiment {} stopped'.format(exp))
812 messages.success(request, 'Experiment {} stopped'.format(exp))
813 else:
813 else:
814 messages.error(request, 'Experiment {} not running'.format(exp))
814 messages.error(request, 'Experiment {} not running'.format(exp))
815
815
816 return redirect(exp.get_absolute_url())
816 return redirect(exp.get_absolute_url())
817
817
818
818
819 def experiment_status(request, id_exp):
819 def experiment_status(request, id_exp):
820
820
821 exp = get_object_or_404(Experiment, pk=id_exp)
821 exp = get_object_or_404(Experiment, pk=id_exp)
822
822
823 exp.get_status()
823 exp.get_status()
824
824
825 return redirect(exp.get_absolute_url())
825 return redirect(exp.get_absolute_url())
826
826
827
827
828 @login_required
828 @login_required
829 def experiment_mix(request, id_exp):
829 def experiment_mix(request, id_exp):
830
830
831 experiment = get_object_or_404(Experiment, pk=id_exp)
831 experiment = get_object_or_404(Experiment, pk=id_exp)
832 rc_confs = [conf for conf in RCConfiguration.objects.filter(
832 rc_confs = [conf for conf in RCConfiguration.objects.filter(
833 experiment=id_exp,
833 experiment=id_exp,
834 type=0,
834 type=0,
835 mix=False)]
835 mix=False)]
836
836
837 if len(rc_confs) < 2:
837 if len(rc_confs) < 2:
838 messages.warning(
838 messages.warning(
839 request, 'You need at least two RC Configurations to make a mix')
839 request, 'You need at least two RC Configurations to make a mix')
840 return redirect(experiment.get_absolute_url())
840 return redirect(experiment.get_absolute_url())
841
841
842 mix_confs = RCConfiguration.objects.filter(experiment=id_exp, mix=True, type=0)
842 mix_confs = RCConfiguration.objects.filter(experiment=id_exp, mix=True, type=0)
843
843
844 if mix_confs:
844 if mix_confs:
845 mix = mix_confs[0]
845 mix = mix_confs[0]
846 else:
846 else:
847 mix = RCConfiguration(experiment=experiment,
847 mix = RCConfiguration(experiment=experiment,
848 device=rc_confs[0].device,
848 device=rc_confs[0].device,
849 ipp=rc_confs[0].ipp,
849 ipp=rc_confs[0].ipp,
850 clock_in=rc_confs[0].clock_in,
850 clock_in=rc_confs[0].clock_in,
851 clock_divider=rc_confs[0].clock_divider,
851 clock_divider=rc_confs[0].clock_divider,
852 mix=True,
852 mix=True,
853 parameters='')
853 parameters='')
854 mix.save()
854 mix.save()
855
855
856 line_type = RCLineType.objects.get(name='mix')
856 line_type = RCLineType.objects.get(name='mix')
857 print("VIew obteniendo len getlines")
857 print("VIew obteniendo len getlines")
858 print(len(rc_confs[0].get_lines()))
858 print(len(rc_confs[0].get_lines()))
859 for i in range(len(rc_confs[0].get_lines())):
859 for i in range(len(rc_confs[0].get_lines())):
860 line = RCLine(rc_configuration=mix, line_type=line_type, channel=i)
860 line = RCLine(rc_configuration=mix, line_type=line_type, channel=i)
861 line.save()
861 line.save()
862
862
863 initial = {'name': mix.name,
863 initial = {'name': mix.name,
864 'result': parse_mix_result(mix.parameters),
864 'result': parse_mix_result(mix.parameters),
865 'delay': 0,
865 'delay': 0,
866 'mask': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
866 'mask': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
867 }
867 }
868
868
869 if request.method == 'GET':
869 if request.method == 'GET':
870 form = RCMixConfigurationForm(confs=rc_confs, initial=initial)
870 form = RCMixConfigurationForm(confs=rc_confs, initial=initial)
871
871
872 if request.method == 'POST':
872 if request.method == 'POST':
873 result = mix.parameters
873 result = mix.parameters
874
874
875 if '{}|'.format(request.POST['experiment']) in result:
875 if '{}|'.format(request.POST['experiment']) in result:
876 messages.error(request, 'Configuration already added')
876 messages.error(request, 'Configuration already added')
877 else:
877 else:
878 if 'operation' in request.POST:
878 if 'operation' in request.POST:
879 operation = MIX_OPERATIONS[request.POST['operation']]
879 operation = MIX_OPERATIONS[request.POST['operation']]
880 else:
880 else:
881 operation = ' '
881 operation = ' '
882
882
883 mode = MIX_MODES[request.POST['mode']]
883 mode = MIX_MODES[request.POST['mode']]
884
884
885 if result:
885 if result:
886 result = '{}-{}|{}|{}|{}|{}'.format(mix.parameters,
886 result = '{}-{}|{}|{}|{}|{}'.format(mix.parameters,
887 request.POST['experiment'],
887 request.POST['experiment'],
888 mode,
888 mode,
889 operation,
889 operation,
890 float(
890 float(
891 request.POST['delay']),
891 request.POST['delay']),
892 parse_mask(
892 parse_mask(
893 request.POST.getlist('mask'))
893 request.POST.getlist('mask'))
894 )
894 )
895 else:
895 else:
896 result = '{}|{}|{}|{}|{}'.format(request.POST['experiment'],
896 result = '{}|{}|{}|{}|{}'.format(request.POST['experiment'],
897 mode,
897 mode,
898 operation,
898 operation,
899 float(request.POST['delay']),
899 float(request.POST['delay']),
900 parse_mask(
900 parse_mask(
901 request.POST.getlist('mask'))
901 request.POST.getlist('mask'))
902 )
902 )
903
903
904 mix.parameters = result
904 mix.parameters = result
905 mix.save()
905 mix.save()
906 mix.update_pulses()
906 mix.update_pulses()
907
907
908 initial['result'] = parse_mix_result(result)
908 initial['result'] = parse_mix_result(result)
909 initial['name'] = mix.name
909 initial['name'] = mix.name
910
910
911 form = RCMixConfigurationForm(initial=initial, confs=rc_confs)
911 form = RCMixConfigurationForm(initial=initial, confs=rc_confs)
912
912
913 kwargs = {
913 kwargs = {
914 'title': 'Experiment',
914 'title': 'Experiment',
915 'suptitle': 'Mix Configurations',
915 'suptitle': 'Mix Configurations',
916 'form': form,
916 'form': form,
917 'extra_button': 'Delete',
917 'extra_button': 'Delete',
918 'button': 'Add',
918 'button': 'Add',
919 'cancel': 'Back',
919 'cancel': 'Back',
920 'previous': experiment.get_absolute_url(),
920 'previous': experiment.get_absolute_url(),
921 'id_exp': id_exp,
921 'id_exp': id_exp,
922
922
923 }
923 }
924 kwargs['menu_experiments'] = 'active'
924 kwargs['menu_experiments'] = 'active'
925
925
926 return render(request, 'experiment_mix.html', kwargs)
926 return render(request, 'experiment_mix.html', kwargs)
927
927
928
928
929 @login_required
929 @login_required
930 def experiment_mix_delete(request, id_exp):
930 def experiment_mix_delete(request, id_exp):
931
931
932 conf = RCConfiguration.objects.get(experiment=id_exp, mix=True, type=0)
932 conf = RCConfiguration.objects.get(experiment=id_exp, mix=True, type=0)
933 values = conf.parameters.split('-')
933 values = conf.parameters.split('-')
934 conf.parameters = '-'.join(values[:-1])
934 conf.parameters = '-'.join(values[:-1])
935 conf.save()
935 conf.save()
936
936
937 return redirect('url_mix_experiment', id_exp=id_exp)
937 return redirect('url_mix_experiment', id_exp=id_exp)
938
938
939
939
940 def experiment_summary(request, id_exp):
940 def experiment_summary(request, id_exp):
941
941
942 experiment = get_object_or_404(Experiment, pk=id_exp)
942 experiment = get_object_or_404(Experiment, pk=id_exp)
943 configurations = Configuration.objects.filter(
943 configurations = Configuration.objects.filter(
944 experiment=experiment, type=0)
944 experiment=experiment, type=0)
945
945
946 kwargs = {}
946 kwargs = {}
947 kwargs['experiment_keys'] = ['radar_system',
947 kwargs['experiment_keys'] = ['radar_system',
948 'name', 'freq', 'start_time', 'end_time']
948 'name', 'freq', 'start_time', 'end_time']
949 kwargs['experiment'] = experiment
949 kwargs['experiment'] = experiment
950 kwargs['configurations'] = []
950 kwargs['configurations'] = []
951 kwargs['title'] = 'Experiment Summary'
951 kwargs['title'] = 'Experiment Summary'
952 kwargs['suptitle'] = 'Details'
952 kwargs['suptitle'] = 'Details'
953 kwargs['button'] = 'Verify Parameters'
953 kwargs['button'] = 'Verify Parameters'
954
954
955 c_vel = 3.0*(10**8) # m/s
955 c_vel = 3.0*(10**8) # m/s
956 ope_freq = experiment.freq*(10**6) # 1/s
956 ope_freq = experiment.freq*(10**6) # 1/s
957 radar_lambda = c_vel/ope_freq # m
957 radar_lambda = c_vel/ope_freq # m
958 kwargs['radar_lambda'] = radar_lambda
958 kwargs['radar_lambda'] = radar_lambda
959
959
960 ipp = None
960 ipp = None
961 nsa = 1
961 nsa = 1
962 code_id = 0
962 code_id = 0
963 tx_line = {}
963 tx_line = {}
964
964
965 for configuration in configurations.filter(device__device_type__name = 'rc'):
965 for configuration in configurations.filter(device__device_type__name = 'rc'):
966
966
967 if configuration.mix:
967 if configuration.mix:
968 continue
968 continue
969 conf = {'conf': configuration}
969 conf = {'conf': configuration}
970 conf['keys'] = []
970 conf['keys'] = []
971 conf['NTxs'] = configuration.ntx
971 conf['NTxs'] = configuration.ntx
972 conf['keys'].append('NTxs')
972 conf['keys'].append('NTxs')
973 ipp = configuration.ipp
973 ipp = configuration.ipp
974 conf['IPP'] = ipp
974 conf['IPP'] = ipp
975 conf['keys'].append('IPP')
975 conf['keys'].append('IPP')
976 lines = configuration.get_lines(line_type__name='tx')
976 lines = configuration.get_lines(line_type__name='tx')
977
977
978 for tx_line in lines:
978 for tx_line in lines:
979 tx_params = json.loads(tx_line.params)
979 tx_params = json.loads(tx_line.params)
980 conf[tx_line.get_name()] = '{} Km'.format(tx_params['pulse_width'])
980 conf[tx_line.get_name()] = '{} Km'.format(tx_params['pulse_width'])
981 conf['keys'].append(tx_line.get_name())
981 conf['keys'].append(tx_line.get_name())
982 delays = tx_params['delays']
982 delays = tx_params['delays']
983 if delays not in ('', '0'):
983 if delays not in ('', '0'):
984 n = len(delays.split(','))
984 n = len(delays.split(','))
985 taus = '{} Taus: {}'.format(n, delays)
985 taus = '{} Taus: {}'.format(n, delays)
986 else:
986 else:
987 taus = '-'
987 taus = '-'
988 conf['Taus ({})'.format(tx_line.get_name())] = taus
988 conf['Taus ({})'.format(tx_line.get_name())] = taus
989 conf['keys'].append('Taus ({})'.format(tx_line.get_name()))
989 conf['keys'].append('Taus ({})'.format(tx_line.get_name()))
990 for code_line in configuration.get_lines(line_type__name='codes'):
990 for code_line in configuration.get_lines(line_type__name='codes'):
991 code_params = json.loads(code_line.params)
991 code_params = json.loads(code_line.params)
992 code_id = code_params['code']
992 code_id = code_params['code']
993 if tx_line.pk == int(code_params['TX_ref']):
993 if tx_line.pk == int(code_params['TX_ref']):
994 conf['Code ({})'.format(tx_line.get_name())] = '{}:{}'.format(RCLineCode.objects.get(pk=code_params['code']),
994 conf['Code ({})'.format(tx_line.get_name())] = '{}:{}'.format(RCLineCode.objects.get(pk=code_params['code']),
995 '-'.join(code_params['codes']))
995 '-'.join(code_params['codes']))
996 conf['keys'].append('Code ({})'.format(tx_line.get_name()))
996 conf['keys'].append('Code ({})'.format(tx_line.get_name()))
997
997
998 for windows_line in configuration.get_lines(line_type__name='windows'):
998 for windows_line in configuration.get_lines(line_type__name='windows'):
999 win_params = json.loads(windows_line.params)
999 win_params = json.loads(windows_line.params)
1000 if tx_line.pk == int(win_params['TX_ref']):
1000 if tx_line.pk == int(win_params['TX_ref']):
1001 windows = ''
1001 windows = ''
1002 nsa = win_params['params'][0]['number_of_samples']
1002 nsa = win_params['params'][0]['number_of_samples']
1003 for i, params in enumerate(win_params['params']):
1003 for i, params in enumerate(win_params['params']):
1004 windows += 'W{}: Ho={first_height} km DH={resolution} km NSA={number_of_samples}<br>'.format(
1004 windows += 'W{}: Ho={first_height} km DH={resolution} km NSA={number_of_samples}<br>'.format(
1005 i, **params)
1005 i, **params)
1006 conf['Window'] = mark_safe(windows)
1006 conf['Window'] = mark_safe(windows)
1007 conf['keys'].append('Window')
1007 conf['keys'].append('Window')
1008
1008
1009 kwargs['configurations'].append(conf)
1009 kwargs['configurations'].append(conf)
1010
1010
1011 for configuration in configurations.filter(device__device_type__name = 'jars'):
1011 for configuration in configurations.filter(device__device_type__name = 'jars'):
1012
1012
1013 conf = {'conf': configuration}
1013 conf = {'conf': configuration}
1014 conf['keys'] = []
1014 conf['keys'] = []
1015 conf['Type of Data'] = EXPERIMENT_TYPE[configuration.exp_type][1]
1015 conf['Type of Data'] = EXPERIMENT_TYPE[configuration.exp_type][1]
1016 conf['keys'].append('Type of Data')
1016 conf['keys'].append('Type of Data')
1017 channels_number = configuration.channels_number
1017 channels_number = configuration.channels_number
1018 exp_type = configuration.exp_type
1018 exp_type = configuration.exp_type
1019 fftpoints = configuration.fftpoints
1019 fftpoints = configuration.fftpoints
1020 filter_parms = json.loads(configuration.filter_parms)
1020 filter_parms = json.loads(configuration.filter_parms)
1021 spectral_number = configuration.spectral_number
1021 spectral_number = configuration.spectral_number
1022 acq_profiles = configuration.acq_profiles
1022 acq_profiles = configuration.acq_profiles
1023 cohe_integr = configuration.cohe_integr
1023 cohe_integr = configuration.cohe_integr
1024 profiles_block = configuration.profiles_block
1024 profiles_block = configuration.profiles_block
1025
1025
1026 conf['Num of Profiles'] = acq_profiles
1026 conf['Num of Profiles'] = acq_profiles
1027 conf['keys'].append('Num of Profiles')
1027 conf['keys'].append('Num of Profiles')
1028
1028
1029 conf['Prof per Block'] = profiles_block
1029 conf['Prof per Block'] = profiles_block
1030 conf['keys'].append('Prof per Block')
1030 conf['keys'].append('Prof per Block')
1031
1031
1032 conf['Blocks per File'] = configuration.raw_data_blocks
1032 conf['Blocks per File'] = configuration.raw_data_blocks
1033 conf['keys'].append('Blocks per File')
1033 conf['keys'].append('Blocks per File')
1034
1034
1035 if exp_type == 0: # Short
1035 if exp_type == 0: # Short
1036 bytes_ = 2
1036 bytes_ = 2
1037 b = nsa*2*bytes_*channels_number
1037 b = nsa*2*bytes_*channels_number
1038 else: # Float
1038 else: # Float
1039 bytes_ = 4
1039 bytes_ = 4
1040 channels = channels_number + spectral_number
1040 channels = channels_number + spectral_number
1041 b = nsa*2*bytes_*fftpoints*channels
1041 b = nsa*2*bytes_*fftpoints*channels
1042
1042
1043 codes_num = 7
1043 codes_num = 7
1044 if code_id == 2:
1044 if code_id == 2:
1045 codes_num = 7
1045 codes_num = 7
1046 elif code_id == 12:
1046 elif code_id == 12:
1047 codes_num = 15
1047 codes_num = 15
1048
1048
1049 #Jars filter values:
1049 #Jars filter values:
1050
1050
1051 clock = float(filter_parms['clock'])
1051 clock = float(filter_parms['clock'])
1052 filter_2 = int(filter_parms['cic_2'])
1052 filter_2 = int(filter_parms['cic_2'])
1053 filter_5 = int(filter_parms['cic_5'])
1053 filter_5 = int(filter_parms['cic_5'])
1054 filter_fir = int(filter_parms['fir'])
1054 filter_fir = int(filter_parms['fir'])
1055 Fs_MHz = clock/(filter_2*filter_5*filter_fir)
1055 Fs_MHz = clock/(filter_2*filter_5*filter_fir)
1056
1056
1057 #Jars values:
1057 #Jars values:
1058 if ipp is not None:
1058 if ipp is not None:
1059 IPP_units = ipp/0.15*Fs_MHz
1059 IPP_units = ipp/0.15*Fs_MHz
1060 IPP_us = IPP_units / Fs_MHz
1060 IPP_us = IPP_units / Fs_MHz
1061 IPP_s = IPP_units / (Fs_MHz * (10**6))
1061 IPP_s = IPP_units / (Fs_MHz * (10**6))
1062 Ts = 1/(Fs_MHz*(10**6))
1062 Ts = 1/(Fs_MHz*(10**6))
1063
1063
1064 Va = radar_lambda/(4*Ts*cohe_integr)
1064 Va = radar_lambda/(4*Ts*cohe_integr)
1065 rate_bh = ((nsa-codes_num)*channels_number*2 *
1065 rate_bh = ((nsa-codes_num)*channels_number*2 *
1066 bytes_/IPP_us)*(36*(10**8)/cohe_integr)
1066 bytes_/IPP_us)*(36*(10**8)/cohe_integr)
1067 rate_gh = rate_bh/(1024*1024*1024)
1067 rate_gh = rate_bh/(1024*1024*1024)
1068
1068
1069 conf['Time per Block'] = IPP_s * profiles_block * cohe_integr
1069 conf['Time per Block'] = IPP_s * profiles_block * cohe_integr
1070 conf['keys'].append('Time per Block')
1070 conf['keys'].append('Time per Block')
1071 conf['Acq time'] = IPP_s * acq_profiles
1071 conf['Acq time'] = IPP_s * acq_profiles
1072 conf['keys'].append('Acq time')
1072 conf['keys'].append('Acq time')
1073 conf['Data rate'] = str(rate_gh)+" (GB/h)"
1073 conf['Data rate'] = str(rate_gh)+" (GB/h)"
1074 conf['keys'].append('Data rate')
1074 conf['keys'].append('Data rate')
1075 conf['Va (m/s)'] = Va
1075 conf['Va (m/s)'] = Va
1076 conf['keys'].append('Va (m/s)')
1076 conf['keys'].append('Va (m/s)')
1077 conf['Vrange (m/s)'] = 3/(2*IPP_s*cohe_integr)
1077 conf['Vrange (m/s)'] = 3/(2*IPP_s*cohe_integr)
1078 conf['keys'].append('Vrange (m/s)')
1078 conf['keys'].append('Vrange (m/s)')
1079
1079
1080 kwargs['configurations'].append(conf)
1080 kwargs['configurations'].append(conf)
1081 kwargs['menu_experiments'] = 'active'
1081 kwargs['menu_experiments'] = 'active'
1082
1082
1083 ###### SIDEBAR ######
1083 ###### SIDEBAR ######
1084 kwargs.update(sidebar(experiment=experiment))
1084 kwargs.update(sidebar(experiment=experiment))
1085
1085
1086 return render(request, 'experiment_summary.html', kwargs)
1086 return render(request, 'experiment_summary.html', kwargs)
1087
1087
1088
1088
1089 @login_required
1089 @login_required
1090 def experiment_verify(request, id_exp):
1090 def experiment_verify(request, id_exp):
1091
1091
1092 experiment = get_object_or_404(Experiment, pk=id_exp)
1092 experiment = get_object_or_404(Experiment, pk=id_exp)
1093 experiment_data = experiment.parms_to_dict()
1093 experiment_data = experiment.parms_to_dict()
1094 configurations = Configuration.objects.filter(
1094 configurations = Configuration.objects.filter(
1095 experiment=experiment, type=0)
1095 experiment=experiment, type=0)
1096
1096
1097 kwargs = {}
1097 kwargs = {}
1098
1098
1099 kwargs['experiment_keys'] = ['template',
1099 kwargs['experiment_keys'] = ['template',
1100 'radar_system', 'name', 'start_time', 'end_time']
1100 'radar_system', 'name', 'start_time', 'end_time']
1101 kwargs['experiment'] = experiment
1101 kwargs['experiment'] = experiment
1102
1102
1103 kwargs['configuration_keys'] = ['name', 'device__ip_address',
1103 kwargs['configuration_keys'] = ['name', 'device__ip_address',
1104 'device__port_address', 'device__status']
1104 'device__port_address', 'device__status']
1105 kwargs['configurations'] = configurations
1105 kwargs['configurations'] = configurations
1106 kwargs['experiment_data'] = experiment_data
1106 kwargs['experiment_data'] = experiment_data
1107
1107
1108 kwargs['title'] = 'Verify Experiment'
1108 kwargs['title'] = 'Verify Experiment'
1109 kwargs['suptitle'] = 'Parameters'
1109 kwargs['suptitle'] = 'Parameters'
1110
1110
1111 kwargs['button'] = 'Update'
1111 kwargs['button'] = 'Update'
1112
1112
1113 jars_conf = False
1113 jars_conf = False
1114 rc_conf = False
1114 rc_conf = False
1115 dds_conf = False
1115 dds_conf = False
1116
1116
1117 for configuration in configurations:
1117 for configuration in configurations:
1118 #-------------------- JARS -----------------------:
1118 #-------------------- JARS -----------------------:
1119 if configuration.device.device_type.name == 'jars':
1119 if configuration.device.device_type.name == 'jars':
1120 jars_conf = True
1120 jars_conf = True
1121 jars = configuration
1121 jars = configuration
1122 kwargs['jars_conf'] = jars_conf
1122 kwargs['jars_conf'] = jars_conf
1123 filter_parms = json.loads(jars.filter_parms)
1123 filter_parms = json.loads(jars.filter_parms)
1124 kwargs['filter_parms'] = filter_parms
1124 kwargs['filter_parms'] = filter_parms
1125 #--Sampling Frequency
1125 #--Sampling Frequency
1126 clock = filter_parms['clock']
1126 clock = filter_parms['clock']
1127 filter_2 = filter_parms['cic_2']
1127 filter_2 = filter_parms['cic_2']
1128 filter_5 = filter_parms['cic_5']
1128 filter_5 = filter_parms['cic_5']
1129 filter_fir = filter_parms['fir']
1129 filter_fir = filter_parms['fir']
1130 samp_freq_jars = clock/filter_2/filter_5/filter_fir
1130 samp_freq_jars = clock/filter_2/filter_5/filter_fir
1131
1131
1132 kwargs['samp_freq_jars'] = samp_freq_jars
1132 kwargs['samp_freq_jars'] = samp_freq_jars
1133 kwargs['jars'] = configuration
1133 kwargs['jars'] = configuration
1134
1134
1135 #--------------------- RC ----------------------:
1135 #--------------------- RC ----------------------:
1136 if configuration.device.device_type.name == 'rc' and not configuration.mix:
1136 if configuration.device.device_type.name == 'rc' and not configuration.mix:
1137 rc_conf = True
1137 rc_conf = True
1138 rc = configuration
1138 rc = configuration
1139
1139
1140 rc_parms = configuration.parms_to_dict()
1140 rc_parms = configuration.parms_to_dict()
1141
1141
1142 win_lines = rc.get_lines(line_type__name='windows')
1142 win_lines = rc.get_lines(line_type__name='windows')
1143 if win_lines:
1143 if win_lines:
1144 dh = json.loads(win_lines[0].params)['params'][0]['resolution']
1144 dh = json.loads(win_lines[0].params)['params'][0]['resolution']
1145 #--Sampling Frequency
1145 #--Sampling Frequency
1146 samp_freq_rc = 0.15/dh
1146 samp_freq_rc = 0.15/dh
1147 kwargs['samp_freq_rc'] = samp_freq_rc
1147 kwargs['samp_freq_rc'] = samp_freq_rc
1148
1148
1149 kwargs['rc_conf'] = rc_conf
1149 kwargs['rc_conf'] = rc_conf
1150 kwargs['rc'] = configuration
1150 kwargs['rc'] = configuration
1151
1151
1152 #-------------------- DDS ----------------------:
1152 #-------------------- DDS ----------------------:
1153 if configuration.device.device_type.name == 'dds':
1153 if configuration.device.device_type.name == 'dds':
1154 dds_conf = True
1154 dds_conf = True
1155 dds = configuration
1155 dds = configuration
1156 dds_parms = configuration.parms_to_dict()
1156 dds_parms = configuration.parms_to_dict()
1157
1157
1158 kwargs['dds_conf'] = dds_conf
1158 kwargs['dds_conf'] = dds_conf
1159 kwargs['dds'] = configuration
1159 kwargs['dds'] = configuration
1160
1160
1161 #------------Validation------------:
1161 #------------Validation------------:
1162 #Clock
1162 #Clock
1163 if dds_conf and rc_conf and jars_conf:
1163 if dds_conf and rc_conf and jars_conf:
1164 if float(filter_parms['clock']) != float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) and float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) != float(dds_parms['configurations']['byId'][str(dds.pk)]['clock']):
1164 if float(filter_parms['clock']) != float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) and float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) != float(dds_parms['configurations']['byId'][str(dds.pk)]['clock']):
1165 messages.warning(request, "Devices don't have the same clock.")
1165 messages.warning(request, "Devices don't have the same clock.")
1166 elif rc_conf and jars_conf:
1166 elif rc_conf and jars_conf:
1167 if float(filter_parms['clock']) != float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']):
1167 if float(filter_parms['clock']) != float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']):
1168 messages.warning(request, "Devices don't have the same clock.")
1168 messages.warning(request, "Devices don't have the same clock.")
1169 elif rc_conf and dds_conf:
1169 elif rc_conf and dds_conf:
1170 if float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) != float(dds_parms['configurations']['byId'][str(dds.pk)]['clock']):
1170 if float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) != float(dds_parms['configurations']['byId'][str(dds.pk)]['clock']):
1171 messages.warning(request, "Devices don't have the same clock.")
1171 messages.warning(request, "Devices don't have the same clock.")
1172 if float(samp_freq_rc) != float(dds_parms['configurations']['byId'][str(dds.pk)]['frequencyA']):
1172 if float(samp_freq_rc) != float(dds_parms['configurations']['byId'][str(dds.pk)]['frequencyA']):
1173 messages.warning(
1173 messages.warning(
1174 request, "Devices don't have the same Frequency A.")
1174 request, "Devices don't have the same Frequency A.")
1175
1175
1176 #------------POST METHOD------------:
1176 #------------POST METHOD------------:
1177 if request.method == 'POST':
1177 if request.method == 'POST':
1178 if request.POST['suggest_clock']:
1178 if request.POST['suggest_clock']:
1179 try:
1179 try:
1180 suggest_clock = float(request.POST['suggest_clock'])
1180 suggest_clock = float(request.POST['suggest_clock'])
1181 except:
1181 except:
1182 messages.warning(request, "Invalid value in CLOCK IN.")
1182 messages.warning(request, "Invalid value in CLOCK IN.")
1183 return redirect('url_verify_experiment', id_exp=experiment.id)
1183 return redirect('url_verify_experiment', id_exp=experiment.id)
1184 else:
1184 else:
1185 suggest_clock = ""
1185 suggest_clock = ""
1186 if suggest_clock:
1186 if suggest_clock:
1187 if rc_conf:
1187 if rc_conf:
1188 rc.clock_in = suggest_clock
1188 rc.clock_in = suggest_clock
1189 rc.save()
1189 rc.save()
1190 if jars_conf:
1190 if jars_conf:
1191 filter_parms = jars.filter_parms
1191 filter_parms = jars.filter_parms
1192 filter_parms = ast.literal_eval(filter_parms)
1192 filter_parms = ast.literal_eval(filter_parms)
1193 filter_parms['clock'] = suggest_clock
1193 filter_parms['clock'] = suggest_clock
1194 jars.filter_parms = json.dumps(filter_parms)
1194 jars.filter_parms = json.dumps(filter_parms)
1195 jars.save()
1195 jars.save()
1196 kwargs['filter_parms'] = filter_parms
1196 kwargs['filter_parms'] = filter_parms
1197 if dds_conf:
1197 if dds_conf:
1198 dds.clock = suggest_clock
1198 dds.clock = suggest_clock
1199 dds.save()
1199 dds.save()
1200
1200
1201 if request.POST['suggest_frequencyA']:
1201 if request.POST['suggest_frequencyA']:
1202 try:
1202 try:
1203 suggest_frequencyA = float(request.POST['suggest_frequencyA'])
1203 suggest_frequencyA = float(request.POST['suggest_frequencyA'])
1204 except:
1204 except:
1205 messages.warning(request, "Invalid value in FREQUENCY A.")
1205 messages.warning(request, "Invalid value in FREQUENCY A.")
1206 return redirect('url_verify_experiment', id_exp=experiment.id)
1206 return redirect('url_verify_experiment', id_exp=experiment.id)
1207 else:
1207 else:
1208 suggest_frequencyA = ""
1208 suggest_frequencyA = ""
1209 if suggest_frequencyA:
1209 if suggest_frequencyA:
1210 if jars_conf:
1210 if jars_conf:
1211 filter_parms = jars.filter_parms
1211 filter_parms = jars.filter_parms
1212 filter_parms = ast.literal_eval(filter_parms)
1212 filter_parms = ast.literal_eval(filter_parms)
1213 filter_parms['fch'] = suggest_frequencyA
1213 filter_parms['fch'] = suggest_frequencyA
1214 jars.filter_parms = json.dumps(filter_parms)
1214 jars.filter_parms = json.dumps(filter_parms)
1215 jars.save()
1215 jars.save()
1216 kwargs['filter_parms'] = filter_parms
1216 kwargs['filter_parms'] = filter_parms
1217 if dds_conf:
1217 if dds_conf:
1218 dds.frequencyA_Mhz = request.POST['suggest_frequencyA']
1218 dds.frequencyA_Mhz = request.POST['suggest_frequencyA']
1219 dds.save()
1219 dds.save()
1220
1220
1221 kwargs['menu_experiments'] = 'active'
1221 kwargs['menu_experiments'] = 'active'
1222 kwargs.update(sidebar(experiment=experiment))
1222 kwargs.update(sidebar(experiment=experiment))
1223 return render(request, 'experiment_verify.html', kwargs)
1223 return render(request, 'experiment_verify.html', kwargs)
1224
1224
1225
1225
1226 def parse_mix_result(s):
1226 def parse_mix_result(s):
1227
1227
1228 values = s.split('-')
1228 values = s.split('-')
1229 html = 'EXP MOD OPE DELAY MASK\r\n'
1229 html = 'EXP MOD OPE DELAY MASK\r\n'
1230
1230
1231 if not values or values[0] in ('', ' '):
1231 if not values or values[0] in ('', ' '):
1232 return mark_safe(html)
1232 return mark_safe(html)
1233
1233
1234 for i, value in enumerate(values):
1234 for i, value in enumerate(values):
1235 if not value:
1235 if not value:
1236 continue
1236 continue
1237 pk, mode, operation, delay, mask = value.split('|')
1237 pk, mode, operation, delay, mask = value.split('|')
1238 conf = RCConfiguration.objects.get(pk=pk)
1238 conf = RCConfiguration.objects.get(pk=pk)
1239 if i == 0:
1239 if i == 0:
1240 html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format(
1240 html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format(
1241 conf.name,
1241 conf.name,
1242 mode,
1242 mode,
1243 ' ',
1243 ' ',
1244 delay,
1244 delay,
1245 mask)
1245 mask)
1246 else:
1246 else:
1247 html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format(
1247 html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format(
1248 conf.name,
1248 conf.name,
1249 mode,
1249 mode,
1250 operation,
1250 operation,
1251 delay,
1251 delay,
1252 mask)
1252 mask)
1253
1253
1254 return mark_safe(html)
1254 return mark_safe(html)
1255
1255
1256
1256
1257 def parse_mask(l):
1257 def parse_mask(l):
1258
1258
1259 values = []
1259 values = []
1260
1260
1261 for x in range(16):
1261 for x in range(16):
1262 if '{}'.format(x) in l:
1262 if '{}'.format(x) in l:
1263 values.append(1)
1263 values.append(1)
1264 else:
1264 else:
1265 values.append(0)
1265 values.append(0)
1266
1266
1267 values.reverse()
1267 values.reverse()
1268
1268
1269 return int(''.join([str(x) for x in values]), 2)
1269 return int(''.join([str(x) for x in values]), 2)
1270
1270
1271
1271
1272 def dev_confs(request):
1272 def dev_confs(request):
1273
1273
1274 page = request.GET.get('page')
1274 page = request.GET.get('page')
1275 order = ('-programmed_date', )
1275 order = ('-programmed_date', )
1276 filters = request.GET.copy()
1276 filters = request.GET.copy()
1277 if 'my configurations' in filters:
1277 if 'my configurations' in filters:
1278 filters.pop('my configurations', None)
1278 filters.pop('my configurations', None)
1279 filters['mine'] = request.user.id
1279 filters['mine'] = request.user.id
1280 kwargs = get_paginator(Configuration, page, order, filters)
1280 kwargs = get_paginator(Configuration, page, order, filters)
1281 fields = ['tags', 'template', 'historical']
1281 fields = ['tags', 'template', 'historical']
1282 if request.user.is_authenticated:
1282 if request.user.is_authenticated:
1283 fields.append('my configurations')
1283 fields.append('my configurations')
1284 form = FilterForm(initial=request.GET, extra_fields=fields)
1284 form = FilterForm(initial=request.GET, extra_fields=fields)
1285 kwargs['keys'] = ['name', 'experiment',
1285 kwargs['keys'] = ['name', 'experiment',
1286 'type', 'programmed_date', 'actions']
1286 'type', 'programmed_date', 'actions']
1287 kwargs['title'] = 'Configuration'
1287 kwargs['title'] = 'Configuration'
1288 kwargs['suptitle'] = 'List'
1288 kwargs['suptitle'] = 'List'
1289 kwargs['no_sidebar'] = True
1289 kwargs['no_sidebar'] = True
1290 kwargs['form'] = form
1290 kwargs['form'] = form
1291 kwargs['add_url'] = reverse('url_add_dev_conf', args=[0])
1291 kwargs['add_url'] = reverse('url_add_dev_conf', args=[0])
1292 filters = request.GET.copy()
1292 filters = request.GET.copy()
1293 filters.pop('page', None)
1293 filters.pop('page', None)
1294 kwargs['q'] = urlencode(filters)
1294 kwargs['q'] = urlencode(filters)
1295 kwargs['menu_configurations'] = 'active'
1295 kwargs['menu_configurations'] = 'active'
1296
1296
1297 return render(request, 'base_list.html', kwargs)
1297 return render(request, 'base_list.html', kwargs)
1298
1298
1299
1299
1300 def dev_conf(request, id_conf):
1300 def dev_conf(request, id_conf):
1301
1301
1302 conf = get_object_or_404(Configuration, pk=id_conf)
1302 conf = get_object_or_404(Configuration, pk=id_conf)
1303
1303
1304 return redirect(conf.get_absolute_url())
1304 return redirect(conf.get_absolute_url())
1305
1305
1306
1306
1307 @login_required
1307 @login_required
1308 def dev_conf_new(request, id_exp=0, id_dev=0):
1308 def dev_conf_new(request, id_exp=0, id_dev=0):
1309
1309
1310 if not is_developer(request.user):
1310 if not is_developer(request.user):
1311 messages.error(
1311 messages.error(
1312 request, 'Developer required, to create new configurations')
1312 request, 'Developer required, to create new configurations')
1313 return redirect('index')
1313 return redirect('index')
1314
1314
1315 initial = {}
1315 initial = {}
1316 kwargs = {}
1316 kwargs = {}
1317
1317
1318 if id_exp != 0:
1318 if id_exp != 0:
1319 initial['experiment'] = id_exp
1319 initial['experiment'] = id_exp
1320
1320
1321 if id_dev != 0:
1321 if id_dev != 0:
1322 initial['device'] = id_dev
1322 initial['device'] = id_dev
1323
1323
1324 if request.method == 'GET':
1324 if request.method == 'GET':
1325
1325
1326 if id_dev:
1326 if id_dev:
1327 kwargs['button'] = 'Create'
1327 kwargs['button'] = 'Create'
1328 device = Device.objects.get(pk=id_dev)
1328 device = Device.objects.get(pk=id_dev)
1329 DevConfForm = CONF_FORMS[device.device_type.name]
1329 DevConfForm = CONF_FORMS[device.device_type.name]
1330 initial['name'] = request.GET['name']
1330 initial['name'] = request.GET['name']
1331 form = DevConfForm(initial=initial)
1331 form = DevConfForm(initial=initial)
1332 else:
1332 else:
1333 if 'template' in request.GET:
1333 if 'template' in request.GET:
1334 if request.GET['template'] == '0':
1334 if request.GET['template'] == '0':
1335 choices = [(conf.pk, '{}'.format(conf))
1335 choices = [(conf.pk, '{}'.format(conf))
1336 for conf in Configuration.objects.filter(template=True)]
1336 for conf in Configuration.objects.filter(template=True)]
1337 form = NewForm(initial={'create_from': 2},
1337 form = NewForm(initial={'create_from': 2},
1338 template_choices=choices)
1338 template_choices=choices)
1339 else:
1339 else:
1340 kwargs['button'] = 'Create'
1340 kwargs['button'] = 'Create'
1341 conf = Configuration.objects.get(
1341 conf = Configuration.objects.get(
1342 pk=request.GET['template'])
1342 pk=request.GET['template'])
1343 id_dev = conf.device.pk
1343 id_dev = conf.device.pk
1344 DevConfForm = CONF_FORMS[conf.device.device_type.name]
1344 DevConfForm = CONF_FORMS[conf.device.device_type.name]
1345 form = DevConfForm(instance=conf,
1345 form = DevConfForm(instance=conf,
1346 initial={'name': '{}_{:%y%m%d}'.format(conf.name, datetime.now()),
1346 initial={'name': '{}_{:%y%m%d}'.format(conf.name, datetime.now()),
1347 'template': False,
1347 'template': False,
1348 'experiment': id_exp})
1348 'experiment': id_exp})
1349 elif 'blank' in request.GET:
1349 elif 'blank' in request.GET:
1350 kwargs['button'] = 'Create'
1350 kwargs['button'] = 'Create'
1351 form = ConfigurationForm(initial=initial)
1351 form = ConfigurationForm(initial=initial)
1352 else:
1352 else:
1353 form = NewForm()
1353 form = NewForm()
1354
1354
1355 if request.method == 'POST':
1355 if request.method == 'POST':
1356
1356
1357 device = Device.objects.get(pk=request.POST['device'])
1357 device = Device.objects.get(pk=request.POST['device'])
1358 DevConfForm = CONF_FORMS[device.device_type.name]
1358 DevConfForm = CONF_FORMS[device.device_type.name]
1359
1359
1360 form = DevConfForm(request.POST)
1360 form = DevConfForm(request.POST)
1361 kwargs['button'] = 'Create'
1361 kwargs['button'] = 'Create'
1362 if form.is_valid():
1362 if form.is_valid():
1363 conf = form.save(commit=False)
1363 conf = form.save(commit=False)
1364 conf.author = request.user
1364 conf.author = request.user
1365 conf.save()
1365 conf.save()
1366
1366
1367 if 'template' in request.GET and conf.device.device_type.name == 'rc':
1367 if 'template' in request.GET and conf.device.device_type.name == 'rc':
1368 lines = RCLine.objects.filter(
1368 lines = RCLine.objects.filter(
1369 rc_configuration=request.GET['template'])
1369 rc_configuration=request.GET['template'])
1370 for line in lines:
1370 for line in lines:
1371 line.clone(rc_configuration=conf)
1371 line.clone(rc_configuration=conf)
1372
1372
1373 new_lines = conf.get_lines()
1373 new_lines = conf.get_lines()
1374 for line in new_lines:
1374 for line in new_lines:
1375 line_params = json.loads(line.params)
1375 line_params = json.loads(line.params)
1376 if 'TX_ref' in line_params:
1376 if 'TX_ref' in line_params:
1377 ref_line = RCLine.objects.get(pk=line_params['TX_ref'])
1377 ref_line = RCLine.objects.get(pk=line_params['TX_ref'])
1378 line_params['TX_ref'] = ['{}'.format(
1378 line_params['TX_ref'] = ['{}'.format(
1379 l.pk) for l in new_lines if l.get_name() == ref_line.get_name()][0]
1379 l.pk) for l in new_lines if l.get_name() == ref_line.get_name()][0]
1380 line.params = json.dumps(line_params)
1380 line.params = json.dumps(line_params)
1381 line.save()
1381 line.save()
1382 elif conf.device.device_type.name == 'rc':
1382 elif conf.device.device_type.name == 'rc':
1383 clk = RCClock(rc_configuration=conf)
1383 clk = RCClock(rc_configuration=conf)
1384 clk.save()
1384 clk.save()
1385
1385
1386 return redirect('url_dev_conf', id_conf=conf.pk)
1386 return redirect('url_dev_conf', id_conf=conf.pk)
1387
1387
1388 kwargs['id_exp'] = id_exp
1388 kwargs['id_exp'] = id_exp
1389 kwargs['form'] = form
1389 kwargs['form'] = form
1390 kwargs['title'] = 'Configuration'
1390 kwargs['title'] = 'Configuration'
1391 kwargs['suptitle'] = 'New'
1391 kwargs['suptitle'] = 'New'
1392 kwargs['menu_configurations'] = 'active'
1392 kwargs['menu_configurations'] = 'active'
1393
1393
1394 if id_dev != 0:
1394 if id_dev != 0:
1395 device = Device.objects.get(pk=id_dev)
1395 device = Device.objects.get(pk=id_dev)
1396 kwargs['device'] = device.device_type.name
1396 kwargs['device'] = device.device_type.name
1397 print(id_exp)
1397 print(id_exp)
1398 return render(request, 'dev_conf_edit.html', kwargs)
1398 return render(request, 'dev_conf_edit.html', kwargs)
1399
1399
1400
1400
1401 @login_required
1401 @login_required
1402 def dev_conf_edit(request, id_conf):
1402 def dev_conf_edit(request, id_conf):
1403
1403
1404 conf = get_object_or_404(Configuration, pk=id_conf)
1404 conf = get_object_or_404(Configuration, pk=id_conf)
1405
1405
1406 DevConfForm = CONF_FORMS[conf.device.device_type.name]
1406 DevConfForm = CONF_FORMS[conf.device.device_type.name]
1407
1407
1408 if request.method == 'GET':
1408 if request.method == 'GET':
1409 form = DevConfForm(instance=conf)
1409 form = DevConfForm(instance=conf)
1410
1410
1411 if request.method == 'POST':
1411 if request.method == 'POST':
1412 form = DevConfForm(request.POST, instance=conf)
1412 form = DevConfForm(request.POST, instance=conf)
1413
1413
1414 if form.is_valid():
1414 if form.is_valid():
1415 form.save()
1415 form.save()
1416 return redirect('url_dev_conf', id_conf=id_conf)
1416 return redirect('url_dev_conf', id_conf=id_conf)
1417
1417
1418 kwargs = {}
1418 kwargs = {}
1419 kwargs['form'] = form
1419 kwargs['form'] = form
1420 kwargs['title'] = 'Device Configuration'
1420 kwargs['title'] = 'Device Configuration'
1421 kwargs['suptitle'] = 'Edit'
1421 kwargs['suptitle'] = 'Edit'
1422 kwargs['button'] = 'Update'
1422 kwargs['button'] = 'Update'
1423 kwargs['menu_configurations'] = 'active'
1423 kwargs['menu_configurations'] = 'active'
1424
1424
1425 ###### SIDEBAR ######
1425 ###### SIDEBAR ######
1426 kwargs.update(sidebar(conf=conf))
1426 kwargs.update(sidebar(conf=conf))
1427
1427
1428 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
1428 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
1429
1429
1430
1430
1431 @login_required
1431 @login_required
1432 def dev_conf_start(request, id_conf):
1432 def dev_conf_start(request, id_conf):
1433
1433
1434 conf = get_object_or_404(Configuration, pk=id_conf)
1434 conf = get_object_or_404(Configuration, pk=id_conf)
1435
1435
1436 if conf.start_device():
1436 if conf.start_device():
1437 messages.success(request, conf.message)
1437 messages.success(request, conf.message)
1438 else:
1438 else:
1439 messages.error(request, conf.message)
1439 messages.error(request, conf.message)
1440
1440
1441 #conf.status_device()
1441 #conf.status_device()
1442
1442
1443 return redirect(conf.get_absolute_url())
1443 return redirect(conf.get_absolute_url())
1444
1444
1445
1445
1446 @login_required
1446 @login_required
1447 def dev_conf_stop(request, id_conf):
1447 def dev_conf_stop(request, id_conf):
1448
1448
1449 conf = get_object_or_404(Configuration, pk=id_conf)
1449 conf = get_object_or_404(Configuration, pk=id_conf)
1450
1450
1451 if conf.stop_device():
1451 if conf.stop_device():
1452 messages.success(request, conf.message)
1452 messages.success(request, conf.message)
1453 else:
1453 else:
1454 messages.error(request, conf.message)
1454 messages.error(request, conf.message)
1455
1455
1456 #conf.status_device()
1456 #conf.status_device()
1457
1457
1458 return redirect(conf.get_absolute_url())
1458 return redirect(conf.get_absolute_url())
1459
1459
1460
1460
1461 @login_required
1461 @login_required
1462 def dev_conf_status(request, id_conf):
1462 def dev_conf_status(request, id_conf):
1463
1463
1464 conf = get_object_or_404(Configuration, pk=id_conf)
1464 conf = get_object_or_404(Configuration, pk=id_conf)
1465
1465
1466 conf_active = Configuration.objects.filter(pk=conf.device.conf_active).first()
1466 conf_active = Configuration.objects.filter(pk=conf.device.conf_active).first()
1467 if conf_active!=conf:
1467 if conf_active!=conf:
1468 url = '#' if conf_active is None else conf_active.get_absolute_url()
1468 url = '#' if conf_active is None else conf_active.get_absolute_url()
1469 label = 'None' if conf_active is None else conf_active.label
1469 label = 'None' if conf_active is None else conf_active.label
1470 messages.warning(
1470 messages.warning(
1471 request,
1471 request,
1472 mark_safe('The current configuration has not been written to device, the active configuration is <a href="{}">{}</a>'.format(
1472 mark_safe('The current configuration has not been written to device, the active configuration is <a href="{}">{}</a>'.format(
1473 url,
1473 url,
1474 label
1474 label
1475 ))
1475 ))
1476 )
1476 )
1477
1477
1478 return redirect(conf.get_absolute_url())
1478 return redirect(conf.get_absolute_url())
1479
1479
1480 if conf.status_device():
1480 if conf.status_device():
1481 messages.success(request, conf.message)
1481 messages.success(request, conf.message)
1482 else:
1482 else:
1483 messages.error(request, conf.message)
1483 messages.error(request, conf.message)
1484
1484
1485 return redirect(conf.get_absolute_url())
1485 return redirect(conf.get_absolute_url())
1486
1486
1487
1487
1488 @login_required
1488 @login_required
1489 def dev_conf_reset(request, id_conf):
1489 def dev_conf_reset(request, id_conf):
1490
1490
1491 conf = get_object_or_404(Configuration, pk=id_conf)
1491 conf = get_object_or_404(Configuration, pk=id_conf)
1492
1492
1493 if conf.reset_device():
1493 if conf.reset_device():
1494 messages.success(request, conf.message)
1494 messages.success(request, conf.message)
1495 else:
1495 else:
1496 messages.error(request, conf.message)
1496 messages.error(request, conf.message)
1497
1497
1498 return redirect(conf.get_absolute_url())
1498 return redirect(conf.get_absolute_url())
1499
1499
1500
1500
1501 @login_required
1501 @login_required
1502 def dev_conf_write(request, id_conf):
1502 def dev_conf_write(request, id_conf):
1503
1503
1504 conf = get_object_or_404(Configuration, pk=id_conf)
1504 conf = get_object_or_404(Configuration, pk=id_conf)
1505
1505
1506 if request.method == 'POST':
1506 if request.method == 'POST':
1507 if conf.write_device():
1507 if conf.write_device():
1508 conf.device.conf_active = conf.pk
1508 conf.device.conf_active = conf.pk
1509 conf.device.save()
1509 conf.device.save()
1510 messages.success(request, conf.message)
1510 messages.success(request, conf.message)
1511 if has_been_modified(conf):
1511 if has_been_modified(conf):
1512 conf.clone(type=1, template=False)
1512 conf.clone(type=1, template=False)
1513 else:
1513 else:
1514 messages.error(request, conf.message)
1514 messages.error(request, conf.message)
1515
1515
1516 return redirect(get_object_or_404(Configuration, pk=id_conf).get_absolute_url())
1516 return redirect(get_object_or_404(Configuration, pk=id_conf).get_absolute_url())
1517
1517
1518 kwargs = {
1518 kwargs = {
1519 'title': 'Write Configuration',
1519 'title': 'Write Configuration',
1520 'suptitle': conf.label,
1520 'suptitle': conf.label,
1521 'message': 'Are you sure yo want to write this {} configuration?'.format(conf.device),
1521 'message': 'Are you sure yo want to write this {} configuration?'.format(conf.device),
1522 'delete': False
1522 'delete': False
1523 }
1523 }
1524 kwargs['menu_configurations'] = 'active'
1524 kwargs['menu_configurations'] = 'active'
1525
1525
1526 return render(request, 'confirm.html', kwargs)
1526 return render(request, 'confirm.html', kwargs)
1527
1527
1528
1528
1529 @login_required
1529 @login_required
1530 def dev_conf_read(request, id_conf):
1530 def dev_conf_read(request, id_conf):
1531
1531
1532 conf = get_object_or_404(Configuration, pk=id_conf)
1532 conf = get_object_or_404(Configuration, pk=id_conf)
1533
1533
1534 DevConfForm = CONF_FORMS[conf.device.device_type.name]
1534 DevConfForm = CONF_FORMS[conf.device.device_type.name]
1535
1535
1536 if request.method == 'GET':
1536 if request.method == 'GET':
1537
1537
1538 parms = conf.read_device()
1538 parms = conf.read_device()
1539 #conf.status_device()
1539 #conf.status_device()
1540
1540
1541 if not parms:
1541 if not parms:
1542 messages.error(request, conf.message)
1542 messages.error(request, conf.message)
1543 return redirect(conf.get_absolute_url())
1543 return redirect(conf.get_absolute_url())
1544
1544
1545 form = DevConfForm(initial=parms, instance=conf)
1545 form = DevConfForm(initial=parms, instance=conf)
1546
1546
1547 if request.method == 'POST':
1547 if request.method == 'POST':
1548 form = DevConfForm(request.POST, instance=conf)
1548 form = DevConfForm(request.POST, instance=conf)
1549
1549
1550 if form.is_valid():
1550 if form.is_valid():
1551 form.save()
1551 form.save()
1552 return redirect(conf.get_absolute_url())
1552 return redirect(conf.get_absolute_url())
1553
1553
1554 messages.error(request, "Parameters could not be saved")
1554 messages.error(request, "Parameters could not be saved")
1555
1555
1556 kwargs = {}
1556 kwargs = {}
1557 kwargs['id_dev'] = conf.id
1557 kwargs['id_dev'] = conf.id
1558 kwargs['form'] = form
1558 kwargs['form'] = form
1559 kwargs['title'] = 'Device Configuration'
1559 kwargs['title'] = 'Device Configuration'
1560 kwargs['suptitle'] = 'Parameters read from device'
1560 kwargs['suptitle'] = 'Parameters read from device'
1561 kwargs['button'] = 'Save'
1561 kwargs['button'] = 'Save'
1562
1562
1563 ###### SIDEBAR ######
1563 ###### SIDEBAR ######
1564 kwargs.update(sidebar(conf=conf))
1564 kwargs.update(sidebar(conf=conf))
1565
1565
1566 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
1566 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
1567
1567
1568
1568
1569 @login_required
1569 @login_required
1570 def dev_conf_import(request, id_conf):
1570 def dev_conf_import(request, id_conf):
1571
1571
1572 conf = get_object_or_404(Configuration, pk=id_conf)
1572 conf = get_object_or_404(Configuration, pk=id_conf)
1573 DevConfForm = CONF_FORMS[conf.device.device_type.name]
1573 DevConfForm = CONF_FORMS[conf.device.device_type.name]
1574
1574
1575 if request.method == 'GET':
1575 if request.method == 'GET':
1576 file_form = UploadFileForm()
1576 file_form = UploadFileForm()
1577
1577
1578 if request.method == 'POST':
1578 if request.method == 'POST':
1579 file_form = UploadFileForm(request.POST, request.FILES)
1579 file_form = UploadFileForm(request.POST, request.FILES)
1580
1580
1581 if file_form.is_valid():
1581 if file_form.is_valid():
1582
1582
1583 data = conf.import_from_file(request.FILES['file'])
1583 data = conf.import_from_file(request.FILES['file'])
1584 parms = Params(data=data).get_conf(
1584 parms = Params(data=data).get_conf(
1585 dtype=conf.device.device_type.name)
1585 dtype=conf.device.device_type.name)
1586
1586
1587 if parms:
1587 if parms:
1588
1588
1589 form = DevConfForm(initial=parms, instance=conf)
1589 form = DevConfForm(initial=parms, instance=conf)
1590
1590
1591 kwargs = {}
1591 kwargs = {}
1592 kwargs['id_dev'] = conf.id
1592 kwargs['id_dev'] = conf.id
1593 kwargs['form'] = form
1593 kwargs['form'] = form
1594 kwargs['title'] = 'Device Configuration'
1594 kwargs['title'] = 'Device Configuration'
1595 kwargs['suptitle'] = 'Parameters imported'
1595 kwargs['suptitle'] = 'Parameters imported'
1596 kwargs['button'] = 'Save'
1596 kwargs['button'] = 'Save'
1597 kwargs['action'] = conf.get_absolute_url_edit()
1597 kwargs['action'] = conf.get_absolute_url_edit()
1598 kwargs['previous'] = conf.get_absolute_url()
1598 kwargs['previous'] = conf.get_absolute_url()
1599
1599
1600 ###### SIDEBAR ######
1600 ###### SIDEBAR ######
1601 kwargs.update(sidebar(conf=conf))
1601 kwargs.update(sidebar(conf=conf))
1602
1602
1603 messages.success(
1603 messages.success(
1604 request, "Parameters imported from: '%s'." % request.FILES['file'].name)
1604 request, "Parameters imported from: '%s'." % request.FILES['file'].name)
1605
1605
1606 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
1606 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
1607
1607
1608 messages.error(request, "Could not import parameters from file")
1608 messages.error(request, "Could not import parameters from file")
1609
1609
1610 kwargs = {}
1610 kwargs = {}
1611 kwargs['id_dev'] = conf.id
1611 kwargs['id_dev'] = conf.id
1612 kwargs['title'] = 'Device Configuration'
1612 kwargs['title'] = 'Device Configuration'
1613 kwargs['form'] = file_form
1613 kwargs['form'] = file_form
1614 kwargs['suptitle'] = 'Importing file'
1614 kwargs['suptitle'] = 'Importing file'
1615 kwargs['button'] = 'Import'
1615 kwargs['button'] = 'Import'
1616 kwargs['menu_configurations'] = 'active'
1616 kwargs['menu_configurations'] = 'active'
1617
1617
1618 kwargs.update(sidebar(conf=conf))
1618 kwargs.update(sidebar(conf=conf))
1619
1619
1620 return render(request, 'dev_conf_import.html', kwargs)
1620 return render(request, 'dev_conf_import.html', kwargs)
1621
1621
1622
1622
1623 @login_required
1623 @login_required
1624 def dev_conf_export(request, id_conf):
1624 def dev_conf_export(request, id_conf):
1625
1625
1626 conf = get_object_or_404(Configuration, pk=id_conf)
1626 conf = get_object_or_404(Configuration, pk=id_conf)
1627
1627
1628 if request.method == 'GET':
1628 if request.method == 'GET':
1629 file_form = DownloadFileForm(conf.device.device_type.name)
1629 file_form = DownloadFileForm(conf.device.device_type.name)
1630
1630
1631 if request.method == 'POST':
1631 if request.method == 'POST':
1632 file_form = DownloadFileForm(
1632 file_form = DownloadFileForm(
1633 conf.device.device_type.name, request.POST)
1633 conf.device.device_type.name, request.POST)
1634
1634
1635 if file_form.is_valid():
1635 if file_form.is_valid():
1636 fields = conf.export_to_file(
1636 fields = conf.export_to_file(
1637 format=file_form.cleaned_data['format'])
1637 format=file_form.cleaned_data['format'])
1638 if not fields['content']:
1638 if not fields['content']:
1639 messages.error(request, conf.message)
1639 messages.error(request, conf.message)
1640 return redirect(conf.get_absolute_url_export())
1640 return redirect(conf.get_absolute_url_export())
1641 response = HttpResponse(content_type=fields['content_type'])
1641 response = HttpResponse(content_type=fields['content_type'])
1642 response['Content-Disposition'] = 'attachment; filename="%s"' % fields['filename']
1642 response['Content-Disposition'] = 'attachment; filename="%s"' % fields['filename']
1643 response.write(fields['content'])
1643 response.write(fields['content'])
1644
1644
1645 return response
1645 return response
1646
1646
1647 messages.error(request, "Could not export parameters")
1647 messages.error(request, "Could not export parameters")
1648
1648
1649 kwargs = {}
1649 kwargs = {}
1650 kwargs['id_dev'] = conf.id
1650 kwargs['id_dev'] = conf.id
1651 kwargs['title'] = 'Device Configuration'
1651 kwargs['title'] = 'Device Configuration'
1652 kwargs['form'] = file_form
1652 kwargs['form'] = file_form
1653 kwargs['suptitle'] = 'Exporting file'
1653 kwargs['suptitle'] = 'Exporting file'
1654 kwargs['button'] = 'Export'
1654 kwargs['button'] = 'Export'
1655 kwargs['menu_configurations'] = 'active'
1655 kwargs['menu_configurations'] = 'active'
1656
1656
1657 return render(request, 'dev_conf_export.html', kwargs)
1657 return render(request, 'dev_conf_export.html', kwargs)
1658
1658
1659
1659
1660 @login_required
1660 @login_required
1661 def dev_conf_delete(request, id_conf):
1661 def dev_conf_delete(request, id_conf):
1662
1662
1663 conf = get_object_or_404(Configuration, pk=id_conf)
1663 conf = get_object_or_404(Configuration, pk=id_conf)
1664
1664
1665 if request.method == 'POST':
1665 if request.method == 'POST':
1666 if is_developer(request.user):
1666 if is_developer(request.user):
1667 conf.delete()
1667 conf.delete()
1668 return redirect('url_dev_confs')
1668 return redirect('url_dev_confs')
1669
1669
1670 messages.error(request, 'Not enough permission to delete this object')
1670 messages.error(request, 'Not enough permission to delete this object')
1671 return redirect(conf.get_absolute_url())
1671 return redirect(conf.get_absolute_url())
1672
1672
1673 kwargs = {
1673 kwargs = {
1674 'title': 'Delete',
1674 'title': 'Delete',
1675 'suptitle': 'Configuration',
1675 'suptitle': 'Configuration',
1676 'object': conf,
1676 'object': conf,
1677 'delete': True
1677 'delete': True
1678 }
1678 }
1679 kwargs['menu_configurations'] = 'active'
1679 kwargs['menu_configurations'] = 'active'
1680
1680
1681 return render(request, 'confirm.html', kwargs)
1681 return render(request, 'confirm.html', kwargs)
1682
1682
1683
1683
1684 def sidebar(**kwargs):
1684 def sidebar(**kwargs):
1685
1685
1686 side_data = {}
1686 side_data = {}
1687
1687
1688 conf = kwargs.get('conf', None)
1688 conf = kwargs.get('conf', None)
1689 experiment = kwargs.get('experiment', None)
1689 experiment = kwargs.get('experiment', None)
1690
1690
1691 if not experiment:
1691 if not experiment:
1692 experiment = conf.experiment
1692 experiment = conf.experiment
1693
1693
1694 if experiment:
1694 if experiment:
1695 side_data['experiment'] = experiment
1695 side_data['experiment'] = experiment
1696 campaign = experiment.campaign_set.all()
1696 campaign = experiment.campaign_set.all()
1697 if campaign:
1697 if campaign:
1698 side_data['campaign'] = campaign[0]
1698 side_data['campaign'] = campaign[0]
1699 experiments = campaign[0].experiments.all().order_by('name')
1699 experiments = campaign[0].experiments.all().order_by('name')
1700 else:
1700 else:
1701 experiments = [experiment]
1701 experiments = [experiment]
1702 configurations = experiment.configuration_set.filter(type=0)
1702 configurations = experiment.configuration_set.filter(type=0)
1703 side_data['side_experiments'] = experiments
1703 side_data['side_experiments'] = experiments
1704 side_data['side_configurations'] = configurations.order_by(
1704 side_data['side_configurations'] = configurations.order_by(
1705 'device__device_type__name')
1705 'device__device_type__name')
1706
1706
1707 return side_data
1707 return side_data
1708
1708
1709 def get_paginator(model, page, order, filters={}, n=8):
1709 def get_paginator(model, page, order, filters={}, n=8):
1710 kwargs = {}
1710 kwargs = {}
1711 query = Q()
1711 query = Q()
1712 if isinstance(filters, QueryDict):
1712 if isinstance(filters, QueryDict):
1713 filters = filters.dict()
1713 filters = filters.dict()
1714 copy_filters=filters.copy()
1714 copy_filters=filters.copy()
1715 [filters.pop(key) for key in copy_filters.keys() if copy_filters[key] in (' ', ' ')]
1715 [filters.pop(key) for key in copy_filters.keys() if copy_filters[key] in (' ', ' ')]
1716 filters.pop('page', None)
1716 filters.pop('page', None)
1717
1717
1718 fields = [f.name for f in model._meta.get_fields()]
1718 fields = [f.name for f in model._meta.get_fields()]
1719
1719
1720 if 'template' in copy_filters:
1720 if 'template' in copy_filters:
1721 filters['template'] = True
1721 filters['template'] = True
1722 if 'historical' in copy_filters:
1722 if 'historical' in copy_filters:
1723 filters.pop('historical')
1723 filters.pop('historical')
1724 filters['type'] = 1
1724 filters['type'] = 1
1725 elif 'type' in fields:
1725 elif 'type' in fields:
1726 filters['type'] = 0
1726 filters['type'] = 0
1727 if 'start_date' in copy_filters:
1727 if 'start_date' in copy_filters:
1728 filters['start_date__gte'] =filters.pop('start_date')
1728 filters['start_date__gte'] =filters.pop('start_date')
1729 if 'end_date' in copy_filters:
1729 if 'end_date' in copy_filters:
1730 filters['start_date__lte'] =filters.pop('end_date')
1730 filters['start_date__lte'] =filters.pop('end_date')
1731 if 'tags' in copy_filters:
1731 if 'tags' in copy_filters:
1732 tags =filters.pop('tags')
1732 tags =filters.pop('tags')
1733 if 'tags' in fields:
1733 if 'tags' in fields:
1734 query = query | Q(tags__icontains=tags)
1734 query = query | Q(tags__icontains=tags)
1735 if 'label' in fields:
1735 if 'label' in fields:
1736 query = query | Q(label__icontains=tags)
1736 query = query | Q(label__icontains=tags)
1737 if 'location' in fields:
1737 if 'location' in fields:
1738 query = query | Q(location__name__icontains=tags)
1738 query = query | Q(location__name__icontains=tags)
1739 if 'device' in fields:
1739 if 'device' in fields:
1740 query = query | Q(device__device_type__name__icontains=tags)
1740 query = query | Q(device__device_type__name__icontains=tags)
1741 query = query | Q(device__location__name__icontains=tags)
1741 query = query | Q(device__location__name__icontains=tags)
1742 if 'device_type' in fields:
1742 if 'device_type' in fields:
1743 query = query | Q(device_type__name__icontains=tags)
1743 query = query | Q(device_type__name__icontains=tags)
1744
1744
1745 if 'mine' in copy_filters:
1745 if 'mine' in copy_filters:
1746 filters['author_id'] =filters['mine']
1746 filters['author_id'] =filters['mine']
1747 filters.pop('mine')
1747 filters.pop('mine')
1748 object_list = model.objects.filter(query, **filters).order_by(*order)
1748 object_list = model.objects.filter(query, **filters).order_by(*order)
1749 paginator = Paginator(object_list, n)
1749 paginator = Paginator(object_list, n)
1750
1750
1751 try:
1751 try:
1752 objects = paginator.page(page)
1752 objects = paginator.page(page)
1753 except PageNotAnInteger:
1753 except PageNotAnInteger:
1754 objects = paginator.page(1)
1754 objects = paginator.page(1)
1755 except EmptyPage:
1755 except EmptyPage:
1756 objects = paginator.page(paginator.num_pages)
1756 objects = paginator.page(paginator.num_pages)
1757
1757
1758 kwargs['objects'] = objects
1758 kwargs['objects'] = objects
1759 kwargs['offset'] = (int(page)-1)*n if page else 0
1759 kwargs['offset'] = (int(page)-1)*n if page else 0
1760
1760
1761 return kwargs
1761 return kwargs
1762
1762
1763 # def get_paginator(model, page, order, filters={}, n=8):
1763 # def get_paginator(model, page, order, filters={}, n=8):
1764 # kwargs = {}
1764 # kwargs = {}
1765 # query = Q()
1765 # query = Q()
1766 # if isinstance(filters, QueryDict):
1766 # if isinstance(filters, QueryDict):
1767 # filters = filters.dict()
1767 # filters = filters.dict()
1768 # [filters.pop(key) for key in filters.keys() if filters[key] in ('', ' ')]
1768 # [filters.pop(key) for key in filters.keys() if filters[key] in ('', ' ')]
1769 # filters.pop('page', None)
1769 # filters.pop('page', None)
1770
1770
1771 # fields = [f.name for f in model._meta.get_fields()]
1771 # fields = [f.name for f in model._meta.get_fields()]
1772
1772
1773 # if 'template' in filters:
1773 # if 'template' in filters:
1774 # filters['template'] = True
1774 # filters['template'] = True
1775 # if 'historical' in filters:
1775 # if 'historical' in filters:
1776 # filters.pop('historical')
1776 # filters.pop('historical')
1777 # filters['type'] = 1
1777 # filters['type'] = 1
1778 # elif 'type' in fields:
1778 # elif 'type' in fields:
1779 # filters['type'] = 0
1779 # filters['type'] = 0
1780 # if 'start_date' in filters:
1780 # if 'start_date' in filters:
1781 # filters['start_date__gte'] = filters.pop('start_date')
1781 # filters['start_date__gte'] = filters.pop('start_date')
1782 # if 'end_date' in filters:
1782 # if 'end_date' in filters:
1783 # filters['start_date__lte'] = filters.pop('end_date')
1783 # filters['start_date__lte'] = filters.pop('end_date')
1784 # if 'tags' in filters:
1784 # if 'tags' in filters:
1785 # tags = filters.pop('tags')
1785 # tags = filters.pop('tags')
1786 # if 'tags' in fields:
1786 # if 'tags' in fields:
1787 # query = query | Q(tags__icontains=tags)
1787 # query = query | Q(tags__icontains=tags)
1788 # if 'label' in fields:
1788 # if 'label' in fields:
1789 # query = query | Q(label__icontains=tags)
1789 # query = query | Q(label__icontains=tags)
1790 # if 'location' in fields:
1790 # if 'location' in fields:
1791 # query = query | Q(location__name__icontains=tags)
1791 # query = query | Q(location__name__icontains=tags)
1792 # if 'device' in fields:
1792 # if 'device' in fields:
1793 # query = query | Q(device__device_type__name__icontains=tags)
1793 # query = query | Q(device__device_type__name__icontains=tags)
1794 # query = query | Q(device__location__name__icontains=tags)
1794 # query = query | Q(device__location__name__icontains=tags)
1795 # if 'device_type' in fields:
1795 # if 'device_type' in fields:
1796 # query = query | Q(device_type__name__icontains=tags)
1796 # query = query | Q(device_type__name__icontains=tags)
1797
1797
1798 # if 'mine' in filters:
1798 # if 'mine' in filters:
1799 # filters['author_id'] = filters['mine']
1799 # filters['author_id'] = filters['mine']
1800 # filters.pop('mine')
1800 # filters.pop('mine')
1801 # object_list = model.objects.filter(query, **filters).order_by(*order)
1801 # object_list = model.objects.filter(query, **filters).order_by(*order)
1802 # paginator = Paginator(object_list, n)
1802 # paginator = Paginator(object_list, n)
1803
1803
1804 # try:
1804 # try:
1805 # objects = paginator.page(page)
1805 # objects = paginator.page(page)
1806 # except PageNotAnInteger:
1806 # except PageNotAnInteger:
1807 # objects = paginator.page(1)
1807 # objects = paginator.page(1)
1808 # except EmptyPage:
1808 # except EmptyPage:
1809 # objects = paginator.page(paginator.num_pages)
1809 # objects = paginator.page(paginator.num_pages)
1810
1810
1811 # kwargs['objects'] = objects
1811 # kwargs['objects'] = objects
1812 # kwargs['offset'] = (int(page)-1)*n if page else 0
1812 # kwargs['offset'] = (int(page)-1)*n if page else 0
1813
1813
1814 # return kwargs
1814 # return kwargs
1815
1815
1816
1816
1817 def operation(request, id_camp=None):
1817 def operation(request, id_camp=None):
1818
1818
1819 kwargs = {}
1819 kwargs = {}
1820 kwargs['title'] = 'Radars Operation'
1820 kwargs['title'] = 'Radars Operation'
1821 kwargs['no_sidebar'] = True
1821 kwargs['no_sidebar'] = True
1822 kwargs['menu_operation'] = 'active'
1822 kwargs['menu_operation'] = 'active'
1823 campaigns = Campaign.objects.filter(start_date__lte=datetime.now(),
1823 campaigns = Campaign.objects.filter(start_date__lte=datetime.now(),
1824 end_date__gte=datetime.now()).order_by('-start_date')
1824 end_date__gte=datetime.now()).order_by('-start_date')
1825
1825
1826 if id_camp:
1826 if id_camp:
1827 campaign = get_object_or_404(Campaign, pk=id_camp)
1827 campaign = get_object_or_404(Campaign, pk=id_camp)
1828 form = OperationForm(
1828 form = OperationForm(
1829 initial={'campaign': campaign.id}, campaigns=campaigns)
1829 initial={'campaign': campaign.id}, campaigns=campaigns)
1830 kwargs['campaign'] = campaign
1830 kwargs['campaign'] = campaign
1831 else:
1831 else:
1832 # form = OperationForm(campaigns=campaigns)
1832 # form = OperationForm(campaigns=campaigns)
1833 kwargs['campaigns'] = campaigns
1833 kwargs['campaigns'] = campaigns
1834 return render(request, 'operation.html', kwargs)
1834 return render(request, 'operation.html', kwargs)
1835
1835
1836 #---Experiment
1836 #---Experiment
1837 keys = ['id', 'name', 'start_time', 'end_time', 'status']
1837 keys = ['id', 'name', 'start_time', 'end_time', 'status']
1838 kwargs['experiment_keys'] = keys[1:]
1838 kwargs['experiment_keys'] = keys[1:]
1839 kwargs['experiments'] = experiments
1839 kwargs['experiments'] = experiments
1840 #---Radar
1840 #---Radar
1841 kwargs['locations'] = campaign.get_experiments_by_radar()
1841 kwargs['locations'] = campaign.get_experiments_by_radar()
1842 kwargs['form'] = form
1842 kwargs['form'] = form
1843
1843
1844 return render(request, 'operation.html', kwargs)
1844 return render(request, 'operation.html', kwargs)
1845
1845
1846
1846
1847 @login_required
1847 @login_required
1848 def radar_start(request, id_camp, id_radar):
1848 def radar_start(request, id_camp, id_radar):
1849
1849
1850 campaign = get_object_or_404(Campaign, pk=id_camp)
1850 campaign = get_object_or_404(Campaign, pk=id_camp)
1851 experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments']
1851 experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments']
1852 now = datetime.now()
1852 now = datetime.now()
1853
1853
1854 for exp in experiments:
1854 for exp in experiments:
1855 #app.control.revoke(exp.task)
1855 #app.control.revoke(exp.task)
1856 print("----------------------")
1856 print("----------------------")
1857 print("status:->", exp.status)
1857 print("status:->", exp.status)
1858 start = datetime.combine(datetime.now().date(), exp.start_time)
1858 start = datetime.combine(datetime.now().date(), exp.start_time)
1859 end = datetime.combine(datetime.now().date(), exp.end_time)
1859 end = datetime.combine(datetime.now().date(), exp.end_time)
1860 print("start exp: ",exp.start_time)
1860 print("start exp: ",exp.start_time)
1861 print("end exp: ",exp.end_time)
1861 print("end exp: ",exp.end_time)
1862
1862
1863 print("start comb: ",start)
1863 print("start comb: ",start)
1864 print("end comb: ",end)
1864 print("end comb: ",end)
1865 print(is_aware(start))
1865 print(is_aware(start))
1866 print("start camp",campaign.start_date)
1866 print("start camp",campaign.start_date)
1867 print("end camp",campaign.end_date)
1867 print("end camp",campaign.end_date)
1868 print(is_aware(campaign.start_date))
1868 print(is_aware(campaign.start_date))
1869 if end < start:
1869 if end < start:
1870 end += timedelta(1)
1870 end += timedelta(1)
1871
1871
1872 if exp.status == 2:
1872 if exp.status == 2:
1873 messages.warning(
1873 messages.warning(
1874 request, 'Experiment {} already running'.format(exp))
1874 request, 'Experiment {} already running'.format(exp))
1875 #continue
1875 #continue
1876
1876
1877 if exp.status == 3:
1877 if exp.status == 3:
1878 messages.warning(
1878 messages.warning(
1879 request, 'Experiment {} already programmed'.format(exp))
1879 request, 'Experiment {} already programmed'.format(exp))
1880 #continue
1880 #continue
1881
1881
1882 if exp.status == 1:
1882 if exp.status == 1:
1883 messages.warning(
1883 messages.warning(
1884 request, 'Experiment {} stopped'.format(exp))
1884 request, 'Experiment {} stopped'.format(exp))
1885 #continue
1885 #continue
1886
1886
1887 if start > campaign.end_date:
1887 if start > campaign.end_date:
1888 messages.warning(
1888 messages.warning(
1889 request, 'Experiment {} out of date'.format(exp))
1889 request, 'Experiment {} out of date'.format(exp))
1890
1890
1891 #app.control.revoke(exp.task)
1891 #app.control.revoke(exp.task)
1892 print("Llego luego del revoke")
1892 print("Llego luego del revoke")
1893 if now >= start and now <= end:
1893 if now >= start and now <= end:
1894
1894
1895 print("Caso now > start and < end -- (1)")
1895 print("Caso now > start and < end -- (1)")
1896
1896
1897 # -------------------------------------------
1897 # -------------------------------------------
1898
1898
1899 # task = task_start.delay(exp.id)
1899 # task = task_start.delay(exp.id)
1900 # exp.task = task.id
1900 # exp.task = task.id
1901 # exp.status = task.get()
1901 # exp.status = task.get()
1902 # -------------------------------------------
1902 # -------------------------------------------
1903
1903
1904 #exp.status = task.wait()
1904 #exp.status = task.wait()
1905
1905
1906 if exp.status == 0:
1906 if exp.status == 0:
1907 messages.error(request, 'Experiment {} not start'.format(exp))
1907 messages.error(request, 'Experiment {} not start'.format(exp))
1908 if exp.status == 2:
1908 if exp.status == 2:
1909 messages.success(request, 'Experiment {} started'.format(exp))
1909 messages.success(request, 'Experiment {} started'.format(exp))
1910 elif now < start:
1910 elif now < start:
1911 print("Caso now <= start -- (2)",exp.pk)
1911 print("Caso now <= start -- (2)",exp.pk)
1912 #task = task_start.apply_async((exp.pk, ), eta=start)#start+timedelta(hours=5))
1912 #task = task_start.apply_async((exp.pk, ), eta=start)#start+timedelta(hours=5))
1913 # task = task_start.apply_async((exp.pk, ), eta=start+timedelta(hours=5))#)
1913 # task = task_start.apply_async((exp.pk, ), eta=start+timedelta(hours=5))#)
1914 # exp.task = task.id
1914 # exp.task = task.id
1915 # exp.status = 3
1915 # exp.status = 3
1916 messages.success(request, 'Experiment {} programmed to start at {}'.format(exp, start))
1916 messages.success(request, 'Experiment {} programmed to start at {}'.format(exp, start))
1917 else:
1917 else:
1918 print("Caso now > end -- (3)")
1918 print("Caso now > end -- (3)")
1919 exp.status = 4
1919 exp.status = 4
1920 messages.warning(
1920 messages.warning(
1921 request, 'Experiment {} out of date'.format(exp))
1921 request, 'Experiment {} out of date'.format(exp))
1922
1922
1923 exp.save()
1923 exp.save()
1924
1924
1925 return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
1925 return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
1926
1926
1927
1927
1928 @login_required
1928 @login_required
1929 def radar_stop(request, id_camp, id_radar):
1929 def radar_stop(request, id_camp, id_radar):
1930
1930
1931 campaign = get_object_or_404(Campaign, pk=id_camp)
1931 campaign = get_object_or_404(Campaign, pk=id_camp)
1932 experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments']
1932 experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments']
1933 print("Ingreso en stop radar_stop")
1933 print("Ingreso en stop radar_stop")
1934 #for exp in experiments:
1934 #for exp in experiments:
1935
1935
1936 # if exp.task:
1936 # if exp.task:
1937 # print("Ingreso antes de revoke stop")
1937 # print("Ingreso antes de revoke stop")
1938 # app.control.revoke(exp.task)
1938 # app.control.revoke(exp.task)
1939
1939
1940
1940
1941 # if exp.status == 2: #status 2 es started
1941 # if exp.status == 2: #status 2 es started
1942 # print("llama a exp.stop")
1942 # print("llama a exp.stop")
1943 # exp.stop()
1943 # exp.stop()
1944 # messages.warning(request, 'Experiment {} stopped'.format(exp))
1944 # messages.warning(request, 'Experiment {} stopped'.format(exp))
1945 # exp.status = 1
1945 # exp.status = 1
1946 # exp.save()
1946 # exp.save()
1947
1947
1948 #return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
1948 #return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
1949
1949
1950
1950
1951 @login_required
1951 @login_required
1952 def radar_refresh(request, id_camp, id_radar):
1952 def radar_refresh(request, id_camp, id_radar):
1953
1953
1954 campaign = get_object_or_404(Campaign, pk=id_camp)
1954 campaign = get_object_or_404(Campaign, pk=id_camp)
1955 experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments']
1955 experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments']
1956
1956
1957 i = app.control.inspect()
1957 i = app.control.inspect()
1958 print("inspect",i)
1958 print("inspect",i)
1959 print(i.scheduled())
1959 print(i.scheduled())
1960 print(i.scheduled().values())
1960 print(i.scheduled().values())
1961 scheduled = list(i.scheduled().values())[0]
1961 scheduled = list(i.scheduled().values())[0]
1962 revoked = list(i.revoked().values())[0]
1962 revoked = list(i.revoked().values())[0]
1963
1963
1964 # for exp in experiments:
1964 # for exp in experiments:
1965 # if exp.task in revoked:
1965 # if exp.task in revoked:
1966 # exp.status = 1
1966 # exp.status = 1
1967 # elif exp.task in [t['request']['id'] for t in scheduled if 'task_stop' in t['request']['name']]:
1967 # elif exp.task in [t['request']['id'] for t in scheduled if 'task_stop' in t['request']['name']]:
1968 # exp.status = 2
1968 # exp.status = 2
1969 # elif exp.task in [t['request']['id'] for t in scheduled if 'task_start' in t['request']['name']]:
1969 # elif exp.task in [t['request']['id'] for t in scheduled if 'task_start' in t['request']['name']]:
1970 # exp.status = 3
1970 # exp.status = 3
1971 # else:
1971 # else:
1972 # exp.status = 4
1972 # exp.status = 4
1973 # exp.save()
1973 # exp.save()
1974 # return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
1974 # return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
1975
1975
1976 #@login_required
1976 #@login_required
1977 # def revoke_tasks(request, id_camp):
1977 # def revoke_tasks(request, id_camp):
1978
1978
1979 # i = app.control.inspect()
1979 # i = app.control.inspect()
1980 # scheduled = list(i.scheduled().values())[0]
1980 # scheduled = list(i.scheduled().values())[0]
1981 # revoked = list(i.revoked().values())[0]
1981 # revoked = list(i.revoked().values())[0]
1982
1982
1983 # for t in scheduled:
1983 # for t in scheduled:
1984 # if t['request']['id'] in revoked:
1984 # if t['request']['id'] in revoked:
1985 # continue
1985 # continue
1986 # app.control.revoke(t['request']['id'])
1986 # app.control.revoke(t['request']['id'])
1987 # exp = Experiment.objects.get(pk=eval(str(t['request']['args']))[0])
1987 # exp = Experiment.objects.get(pk=eval(str(t['request']['args']))[0])
1988 # eta = t['eta']
1988 # eta = t['eta']
1989 # #task = t['request']['name'].split('.')[-1]
1989 # #task = t['request']['name'].split('.')[-1]
1990 # messages.warning(request, 'Scheduled {} at {} for experiment {} revoked'.format(task, eta, exp.name))
1990 # messages.warning(request, 'Scheduled {} at {} for experiment {} revoked'.format(task, eta, exp.name))
1991
1991
1992 # return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
1992 # return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
1993
1993
1994 # @login_required
1994 # @login_required
1995 # def show_tasks(request, id_camp):
1995 # def show_tasks(request, id_camp):
1996
1996
1997 # i = app.control.inspect()
1997 # i = app.control.inspect()
1998 # scheduled = list(i.scheduled().values())[0]
1998 # scheduled = list(i.scheduled().values())[0]
1999 # revoked = list(i.revoked().values())[0]
1999 # revoked = list(i.revoked().values())[0]
2000
2000
2001 # for t in scheduled:
2001 # for t in scheduled:
2002 # if t['request']['id'] in revoked:
2002 # if t['request']['id'] in revoked:
2003 # continue
2003 # continue
2004 # exp = Experiment.objects.get(pk=eval(str(t['request']['args']))[0])
2004 # exp = Experiment.objects.get(pk=eval(str(t['request']['args']))[0])
2005 # eta = t['eta']
2005 # eta = t['eta']
2006 # #task = t['request']['name'].split('.')[-1]
2006 # #task = t['request']['name'].split('.')[-1]
2007 # #messages.success(request, 'Task {} scheduled at {} for experiment {}'.format(task, eta, exp.name))
2007 # #messages.success(request, 'Task {} scheduled at {} for experiment {}'.format(task, eta, exp.name))
2008
2008
2009 # return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
2009 # return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
2010
2010
2011 def real_time(request):
2011 def real_time(request):
2012
2012
2013 graphic_path = "/home/fiorella/Pictures/catwbeanie.jpg"
2013 graphic_path = "/home/fiorella/Pictures/catwbeanie.jpg"
2014
2014
2015 kwargs = {}
2015 kwargs = {}
2016 kwargs['title'] = 'CLAIRE'
2016 kwargs['title'] = 'CLAIRE'
2017 kwargs['suptitle'] = 'Real Time'
2017 kwargs['suptitle'] = 'Real Time'
2018 kwargs['no_sidebar'] = True
2018 kwargs['no_sidebar'] = True
2019 kwargs['graphic_path'] = graphic_path
2019 kwargs['graphic_path'] = graphic_path
2020 kwargs['graphic1_path'] = 'http://www.bluemaize.net/im/girls-accessories/shark-beanie-11.jpg'
2020 kwargs['graphic1_path'] = 'http://www.bluemaize.net/im/girls-accessories/shark-beanie-11.jpg'
2021
2021
2022 return render(request, 'real_time.html', kwargs)
2022 return render(request, 'real_time.html', kwargs)
2023
2023
2024 def theme(request, theme):
2024 def theme(request, theme):
2025
2025
2026 user = request.user
2026 user = request.user
2027 user.profile.theme = theme
2027 user.profile.theme = theme
2028 user.save()
2028 user.save()
2029 return redirect('index')
2029 return redirect('index')
General Comments 0
You need to be logged in to leave comments. Login now