##// END OF EJS Templates
radarsys
RSS
Add device status in experiment view...
Juan C. Espinoza -
r120:7c80e68fc916
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,579 +1,593
1 1 from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
2 2 from datetime import datetime
3 3
4 4 from django.db import models
5 5 from polymorphic import PolymorphicModel
6 6
7 7 from django.core.urlresolvers import reverse
8 8
9 9
10 10 CONF_STATES = (
11 11 (0, 'Disconnected'),
12 12 (1, 'Connected'),
13 13 (2, 'Running'),
14 14 )
15 15
16 16 EXP_STATES = (
17 17 (0,'Error'), #RED
18 (1,'Configurated'), #BLUE
18 (1,'Configured'), #BLUE
19 19 (2,'Running'), #GREEN
20 20 (3,'Waiting'), #YELLOW
21 21 (4,'Not Configured'), #WHITE
22 22 )
23 23
24 24 CONF_TYPES = (
25 25 (0, 'Active'),
26 26 (1, 'Historical'),
27 27 )
28 28
29 29 DEV_STATES = (
30 30 (0, 'No connected'),
31 31 (1, 'Connected'),
32 32 (2, 'Configured'),
33 33 (3, 'Running'),
34 34 )
35 35
36 36 DEV_TYPES = (
37 37 ('', 'Select a device type'),
38 38 ('rc', 'Radar Controller'),
39 39 ('rc_mix', 'Radar Controller (Mix)'),
40 40 ('dds', 'Direct Digital Synthesizer'),
41 41 ('jars', 'Jicamarca Radar Acquisition System'),
42 42 ('usrp', 'Universal Software Radio Peripheral'),
43 43 ('cgs', 'Clock Generator System'),
44 44 ('abs', 'Automatic Beam Switching'),
45 45 )
46 46
47 47 DEV_PORTS = {
48 48 'rc' : 2000,
49 49 'rc_mix': 2000,
50 50 'dds' : 2000,
51 51 'jars' : 2000,
52 52 'usrp' : 2000,
53 53 'cgs' : 8080,
54 54 'abs' : 8080
55 55 }
56 56
57 57 RADAR_STATES = (
58 58 (0, 'No connected'),
59 59 (1, 'Connected'),
60 60 (2, 'Configured'),
61 61 (3, 'Running'),
62 62 (4, 'Scheduled'),
63 63 )
64 64 # Create your models here.
65 65
66 66 class Location(models.Model):
67 67
68 68 name = models.CharField(max_length = 30)
69 69 description = models.TextField(blank=True, null=True)
70 70
71 71 class Meta:
72 72 db_table = 'db_location'
73 73
74 74 def __unicode__(self):
75 75 return u'%s' % self.name
76 76
77 77 def get_absolute_url(self):
78 78 return reverse('url_device', args=[str(self.id)])
79 79
80 80
81 81 class DeviceType(models.Model):
82 82
83 83 name = models.CharField(max_length = 10, choices = DEV_TYPES, default = 'rc')
84 84 description = models.TextField(blank=True, null=True)
85 85
86 86 class Meta:
87 87 db_table = 'db_device_types'
88 88
89 89 def __unicode__(self):
90 90 return u'%s' % self.get_name_display()
91 91
92 92 class Device(models.Model):
93 93
94 94 device_type = models.ForeignKey(DeviceType, on_delete=models.CASCADE)
95 95 location = models.ForeignKey(Location, on_delete=models.CASCADE)
96 96
97 97 name = models.CharField(max_length=40, default='')
98 98 ip_address = models.GenericIPAddressField(protocol='IPv4', default='0.0.0.0')
99 99 port_address = models.PositiveSmallIntegerField(default=2000)
100 100 description = models.TextField(blank=True, null=True)
101 101 status = models.PositiveSmallIntegerField(default=0, choices=DEV_STATES)
102 102
103 103 class Meta:
104 104 db_table = 'db_devices'
105 105
106 106 def __unicode__(self):
107 107 return u'%s | %s' % (self.name, self.ip_address)
108 108
109 109 def get_status(self):
110 110 return self.status
111 111
112 @property
113 def status_color(self):
114 color = 'muted'
115 if self.status == 0:
116 color = "danger"
117 elif self.status == 1:
118 color = "warning"
119 elif self.status == 2:
120 color = "info"
121 elif self.status == 3:
122 color = "success"
123
124 return color
125
112 126 def get_absolute_url(self):
113 127 return reverse('url_device', args=[str(self.id)])
114 128
115 129
116 130 class Campaign(models.Model):
117 131
118 132 template = models.BooleanField(default=False)
119 133 name = models.CharField(max_length=60, unique=True)
120 134 start_date = models.DateTimeField(blank=True, null=True)
121 135 end_date = models.DateTimeField(blank=True, null=True)
122 136 tags = models.CharField(max_length=40)
123 137 description = models.TextField(blank=True, null=True)
124 138 experiments = models.ManyToManyField('Experiment', blank=True)
125 139
126 140 class Meta:
127 141 db_table = 'db_campaigns'
128 142 ordering = ('name',)
129 143
130 144 def __unicode__(self):
131 145 return u'%s' % (self.name)
132 146
133 147 def get_absolute_url(self):
134 148 return reverse('url_campaign', args=[str(self.id)])
135 149
136 150 def parms_to_dict(self):
137 151
138 152 import json
139 153
140 154 parameters = {}
141 155 exp_parameters = {}
142 156 experiments = Experiment.objects.filter(campaign = self)
143 157
144 158 i=1
145 159 for experiment in experiments:
146 160 exp_parameters['experiment-'+str(i)] = json.loads(experiment.parms_to_dict())
147 161 i += 1
148 162
149 163
150 164 parameters['experiments'] = exp_parameters
151 165 parameters['end_date'] = self.end_date.strftime("%Y-%m-%d")
152 166 parameters['start_date'] = self.start_date.strftime("%Y-%m-%d")
153 167 parameters['campaign'] = self.__unicode__()
154 168 parameters['tags'] =self.tags
155 169
156 170 parameters = json.dumps(parameters, indent=2, sort_keys=False)
157 171
158 172 return parameters
159 173
160 174 def import_from_file(self, fp):
161 175
162 176 import os, json
163 177
164 178 parms = {}
165 179
166 180 path, ext = os.path.splitext(fp.name)
167 181
168 182 if ext == '.json':
169 183 parms = json.load(fp)
170 184
171 185 return parms
172 186
173 187 def dict_to_parms(self, parms, CONF_MODELS):
174 188
175 189 experiments = Experiment.objects.filter(campaign = self)
176 190 configurations = Configuration.objects.filter(experiment = experiments)
177 191
178 192 if configurations:
179 193 for configuration in configurations:
180 194 configuration.delete()
181 195
182 196 if experiments:
183 197 for experiment in experiments:
184 198 experiment.delete()
185 199
186 200 for parms_exp in parms['experiments']:
187 201 location = Location.objects.get(name = parms['experiments'][parms_exp]['radar'])
188 202 new_exp = Experiment(
189 203 name = parms['experiments'][parms_exp]['experiment'],
190 204 location = location,
191 205 start_time = parms['experiments'][parms_exp]['start_time'],
192 206 end_time = parms['experiments'][parms_exp]['end_time'],
193 207 )
194 208 new_exp.save()
195 209 new_exp.dict_to_parms(parms['experiments'][parms_exp],CONF_MODELS)
196 210 new_exp.save()
197 211
198 212 self.name = parms['campaign']
199 213 self.start_date = parms['start_date']
200 214 self.end_date = parms['end_date']
201 215 self.tags = parms['tags']
202 216 self.experiments.add(new_exp)
203 217 self.save()
204 218
205 219 return self
206 220
207 221 def get_absolute_url(self):
208 222 return reverse('url_campaign', args=[str(self.id)])
209 223
210 224 def get_absolute_url_edit(self):
211 225 return reverse('url_edit_campaign', args=[str(self.id)])
212 226
213 227 def get_absolute_url_export(self):
214 228 return reverse('url_export_campaign', args=[str(self.id)])
215 229
216 230 def get_absolute_url_import(self):
217 231 return reverse('url_import_campaign', args=[str(self.id)])
218 232
219 233
220 234
221 235 class RunningExperiment(models.Model):
222 236 radar = models.OneToOneField('Location', on_delete=models.CASCADE)
223 237 running_experiment = models.ManyToManyField('Experiment', blank = True)
224 238 status = models.PositiveSmallIntegerField(default=0, choices=RADAR_STATES)
225 239
226 240
227 241 class Experiment(models.Model):
228 242
229 243 template = models.BooleanField(default=False)
230 244 name = models.CharField(max_length=40, default='', unique=True)
231 245 location = models.ForeignKey('Location', null=True, blank=True, on_delete=models.CASCADE)
232 246 start_time = models.TimeField(default='00:00:00')
233 247 end_time = models.TimeField(default='23:59:59')
234 248 status = models.PositiveSmallIntegerField(default=0, choices=EXP_STATES)
235 249
236 250 class Meta:
237 251 db_table = 'db_experiments'
238 252 ordering = ('template', 'name')
239 253
240 254 def __unicode__(self):
241 255 if self.template:
242 256 return u'%s (template)' % (self.name)
243 257 else:
244 258 return u'%s' % (self.name)
245 259
246 260 @property
247 261 def radar(self):
248 262 return self.location
249 263
250 264 def clone(self, **kwargs):
251 265
252 266 confs = Configuration.objects.filter(experiment=self, type=0)
253 267 self.pk = None
254 268 self.name = '{} [{:%Y/%m/%d}]'.format(self.name, datetime.now())
255 269 for attr, value in kwargs.items():
256 270 setattr(self, attr, value)
257 271
258 272 self.save()
259 273
260 274 for conf in confs:
261 275 conf.clone(experiment=self, template=False)
262 276
263 277 return self
264 278
265 279 def get_status(self):
266 280 configurations = Configuration.objects.filter(experiment=self)
267 281 exp_status=[]
268 282 for conf in configurations:
269 283 print conf.status_device()
270 284 exp_status.append(conf.status_device())
271 285
272 286 if not exp_status: #No Configuration
273 287 self.status = 4
274 288 self.save()
275 289 return
276 290
277 291 total = 1
278 292 for e_s in exp_status:
279 293 total = total*e_s
280 294
281 295 if total == 0: #Error
282 296 status = 0
283 297 elif total == (3**len(exp_status)): #Running
284 298 status = 2
285 299 else:
286 300 status = 1 #Configurated
287 301
288 302 self.status = status
289 303 self.save()
290 304
291 305 def status_color(self):
292 306 color = 'danger'
293 307 if self.status == 0:
294 308 color = "danger"
295 309 elif self.status == 1:
296 310 color = "info"
297 311 elif self.status == 2:
298 312 color = "success"
299 313 elif self.status == 3:
300 314 color = "warning"
301 315 else:
302 316 color = "muted"
303 317
304 318 return color
305 319
306 320 def get_absolute_url(self):
307 321 return reverse('url_experiment', args=[str(self.id)])
308 322
309 323 def parms_to_dict(self):
310 324
311 325 import json
312 326
313 327 configurations = Configuration.objects.filter(experiment=self)
314 328 conf_parameters = {}
315 329 parameters={}
316 330
317 331 for configuration in configurations:
318 332 if 'cgs' in configuration.device.device_type.name:
319 333 conf_parameters['cgs'] = configuration.parms_to_dict()
320 334 if 'dds' in configuration.device.device_type.name:
321 335 conf_parameters['dds'] = configuration.parms_to_dict()
322 336 if 'rc' in configuration.device.device_type.name:
323 337 conf_parameters['rc'] = configuration.parms_to_dict()
324 338 if 'jars' in configuration.device.device_type.name:
325 339 conf_parameters['jars'] = configuration.parms_to_dict()
326 340 if 'usrp' in configuration.device.device_type.name:
327 341 conf_parameters['usrp'] = configuration.parms_to_dict()
328 342 if 'abs' in configuration.device.device_type.name:
329 343 conf_parameters['abs'] = configuration.parms_to_dict()
330 344
331 345 parameters['configurations'] = conf_parameters
332 346 parameters['end_time'] = self.end_time.strftime("%H:%M:%S")
333 347 parameters['start_time'] = self.start_time.strftime("%H:%M:%S")
334 348 parameters['radar'] = self.radar.name
335 349 parameters['experiment'] = self.name
336 350 parameters = json.dumps(parameters, indent=2)
337 351
338 352 return parameters
339 353
340 354 def import_from_file(self, fp):
341 355
342 356 import os, json
343 357
344 358 parms = {}
345 359
346 360 path, ext = os.path.splitext(fp.name)
347 361
348 362 if ext == '.json':
349 363 parms = json.load(fp)
350 364
351 365 return parms
352 366
353 367 def dict_to_parms(self, parms, CONF_MODELS):
354 368
355 369 configurations = Configuration.objects.filter(experiment=self)
356 370
357 371 if configurations:
358 372 for configuration in configurations:
359 373 configuration.delete()
360 374
361 375 for conf_type in parms['configurations']:
362 376 #--For ABS Device:
363 377 #--For USRP Device:
364 378 #--For JARS Device:
365 379 #--For RC Device:
366 380 if conf_type == 'rc':
367 381 device = get_object_or_404(Device, pk=parms['configurations']['rc']['device_id'])
368 382 DevConfModel = CONF_MODELS[conf_type]
369 383 confrc_form = DevConfModel(
370 384 experiment = self,
371 385 name = 'RC',
372 386 device=device,
373 387 )
374 388 confrc_form.dict_to_parms(parms['configurations']['rc'])
375 389 confrc_form.save()
376 390 #--For DDS Device:
377 391 if conf_type == 'dds':
378 392 device = get_object_or_404(Device, pk=parms['configurations']['dds']['device_id'])
379 393 DevConfModel = CONF_MODELS[conf_type]
380 394 confdds_form = DevConfModel(
381 395 experiment = self,
382 396 name = 'DDS',
383 397 device=device,
384 398 )
385 399 confdds_form.dict_to_parms(parms['configurations']['dds'])
386 400 confdds_form.save()
387 401 #--For CGS Device:
388 402 if conf_type == 'cgs':
389 403 device = get_object_or_404(Device, pk=parms['configurations']['cgs']['device_id'])
390 404 DevConfModel = CONF_MODELS[conf_type]
391 405 confcgs_form = DevConfModel(
392 406 experiment = self,
393 407 name = 'CGS',
394 408 device=device,
395 409 )
396 410 confcgs_form.dict_to_parms(parms['configurations']['cgs'])
397 411 confcgs_form.save()
398 412
399 413 location = Location.objects.get(name = parms['radar'])
400 414 self.name = parms['experiment']
401 415 self.location = location
402 416 self.start_time = parms['start_time']
403 417 self.end_time = parms['end_time']
404 418 self.save()
405 419
406 420 return self
407 421
408 422 def get_absolute_url_edit(self):
409 423 return reverse('url_edit_experiment', args=[str(self.id)])
410 424
411 425 def get_absolute_url_import(self):
412 426 return reverse('url_import_experiment', args=[str(self.id)])
413 427
414 428 def get_absolute_url_export(self):
415 429 return reverse('url_export_experiment', args=[str(self.id)])
416 430
417 431
418 432 class Configuration(PolymorphicModel):
419 433
420 434 template = models.BooleanField(default=False)
421 435
422 436 name = models.CharField(verbose_name="Configuration Name", max_length=40, default='')
423 437
424 438 experiment = models.ForeignKey('Experiment', null=True, blank=True, on_delete=models.CASCADE)
425 439 device = models.ForeignKey(Device, null=True, on_delete=models.CASCADE)
426 440
427 441 type = models.PositiveSmallIntegerField(default=0, choices=CONF_TYPES)
428 442
429 443 created_date = models.DateTimeField(auto_now_add=True)
430 444 programmed_date = models.DateTimeField(auto_now=True)
431 445
432 446 parameters = models.TextField(default='{}')
433 447
434 448 message = ""
435 449
436 450 class Meta:
437 451 db_table = 'db_configurations'
438 452
439 453 def __unicode__(self):
440 454
441 455 return u'[%s]: %s' % (self.device.name, self.name)
442 456
443 457 def clone(self, **kwargs):
444 458
445 459 self.pk = None
446 460 self.id = None
447 461 for attr, value in kwargs.items():
448 462 setattr(self, attr, value)
449 463
450 464 self.save()
451 465
452 466 return self
453 467
454 468 def parms_to_dict(self):
455 469
456 470 parameters = {}
457 471
458 472 for key in self.__dict__.keys():
459 473 parameters[key] = getattr(self, key)
460 474
461 475 return parameters
462 476
463 477 def parms_to_text(self):
464 478
465 479 raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
466 480
467 481 return ''
468 482
469 483 def parms_to_binary(self):
470 484
471 485 raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
472 486
473 487 return ''
474 488
475 489 def dict_to_parms(self, parameters):
476 490
477 491 if type(parameters) != type({}):
478 492 return
479 493
480 494 for key in parameters.keys():
481 495 setattr(self, key, parameters[key])
482 496
483 497 def export_to_file(self, format="json"):
484 498
485 499 import json
486 500
487 501 content_type = ''
488 502
489 503 if format == 'text':
490 504 content_type = 'text/plain'
491 505 filename = '%s_%s.%s' %(self.device.device_type.name, self.name, self.device.device_type.name)
492 506 content = self.parms_to_text()
493 507
494 508 if format == 'binary':
495 509 content_type = 'application/octet-stream'
496 510 filename = '%s_%s.bin' %(self.device.device_type.name, self.name)
497 511 content = self.parms_to_binary()
498 512
499 513 if not content_type:
500 514 content_type = 'application/json'
501 515 filename = '%s_%s.json' %(self.device.device_type.name, self.name)
502 516 content = json.dumps(self.parms_to_dict(), indent=2)
503 517
504 518 fields = {'content_type':content_type,
505 519 'filename':filename,
506 520 'content':content
507 521 }
508 522
509 523 return fields
510 524
511 525 def import_from_file(self, fp):
512 526
513 527 import os, json
514 528
515 529 parms = {}
516 530
517 531 path, ext = os.path.splitext(fp.name)
518 532
519 533 if ext == '.json':
520 534 parms = json.load(fp)
521 535
522 536 return parms
523 537
524 538 def status_device(self):
525 539
526 540 raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
527 541
528 542 return None
529 543
530 544 def stop_device(self):
531 545
532 546 raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
533 547
534 548 return None
535 549
536 550 def start_device(self):
537 551
538 552 raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
539 553
540 554 return None
541 555
542 556 def write_device(self, parms):
543 557
544 558 raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
545 559
546 560 return None
547 561
548 562 def read_device(self):
549 563
550 564 raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
551 565
552 566 return None
553 567
554 568 def get_absolute_url(self):
555 569 return reverse('url_%s_conf' % self.device.device_type.name, args=[str(self.id)])
556 570
557 571 def get_absolute_url_edit(self):
558 572 return reverse('url_edit_%s_conf' % self.device.device_type.name, args=[str(self.id)])
559 573
560 574 def get_absolute_url_import(self):
561 575 return reverse('url_import_dev_conf', args=[str(self.id)])
562 576
563 577 def get_absolute_url_export(self):
564 578 return reverse('url_export_dev_conf', args=[str(self.id)])
565 579
566 580 def get_absolute_url_write(self):
567 581 return reverse('url_write_dev_conf', args=[str(self.id)])
568 582
569 583 def get_absolute_url_read(self):
570 584 return reverse('url_read_dev_conf', args=[str(self.id)])
571 585
572 586 def get_absolute_url_start(self):
573 587 return reverse('url_start_dev_conf', args=[str(self.id)])
574 588
575 589 def get_absolute_url_stop(self):
576 590 return reverse('url_stop_dev_conf', args=[str(self.id)])
577 591
578 592 def get_absolute_url_status(self):
579 593 return reverse('url_status_dev_conf', args=[str(self.id)]) No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,96 +1,100
1 1 {% extends "base.html" %}
2 2 {% load bootstrap3 %}
3 3 {% load static %}
4 4 {% load main_tags %}
5 5 {% block extra-head %}
6 6 <link href="{% static 'css/bootstrap-datetimepicker.min.css' %}" media="screen" rel="stylesheet">
7 7 {% endblock %}
8 8
9 9 {% block exp-active %}active{% endblock %}
10 10
11 11 {% block content-title %}{{title}}{% endblock %}
12 12 {% block content-suptitle %}{{suptitle}}{% endblock %}
13 13
14 14 {% block content %}
15 15
16 16 {% block menu-actions %}
17 17 <span class=" dropdown pull-right">
18 18 <a href="#" class="dropdown-toggle" data-toggle="dropdown"><span class="glyphicon glyphicon-menu-hamburger gi-2x" aria-hidden="true"></span></a>
19 19 <ul class="dropdown-menu" role="menu">
20 20 <li><a href="{% url 'url_edit_experiment' experiment.id %}"><span class="glyphicon glyphicon-pencil" aria-hidden="true"></span> Edit</a></li>
21 21 <li><a href="{% url 'url_delete_experiment' experiment.id %}"><span class="glyphicon glyphicon-remove" aria-hidden="true"></span> Delete</a></li>
22 22 <li><a href="{{ experiment.get_absolute_url_import }}"><span class="glyphicon glyphicon-import" aria-hidden="true"></span> Import </a></li>
23 23 <li><a href="{{ experiment.get_absolute_url_export }}"><span class="glyphicon glyphicon-export" aria-hidden="true"></span> Export </a></li>
24 24 {% block extra-menu-actions %}
25 25 {% endblock %}
26 26 <li><a>----------------</a></li>
27 27 <li><a href="{% url 'url_mix_experiment' experiment.id %}"><span class="glyphicon glyphicon-random" aria-hidden="true"></span> Mix RC Configurations </a></li>
28 28 <li><a href="{% url 'url_add_dev_conf' experiment.id %}"><span class="glyphicon glyphicon-plus-sign" aria-hidden="true"></span> Add Configuration</a></li>
29 29
30 30 </ul>
31 31 </span>
32 32 {% endblock %}
33 33
34 34 <table class="table table-bordered">
35 35 {% for key in experiment_keys %}
36 36 <tr><th>{{key|title}}</th><td>{{experiment|attr:key}}</td></tr>
37 37 {% endfor %}
38 38 </table>
39 39 <br></br>
40 40 <br></br>
41 41
42 42 <div class="panel-group" id="accordion" role="tablist" aria-multiselectable="true">
43 43
44 44 <div class="panel panel-default">
45 45 <div class="panel-heading" role="tab" id="headingTwo">
46 46 <h4 class="panel-title">
47 47 <a class="collapsed" role="button" data-toggle="collapse" data-parent="#accordion" href="#collapseTwo" aria-expanded="false" aria-controls="collapseThree">
48 48 Device Configurations
49 49 </a>
50 50 </h4>
51 51 </div>
52 52 <div id="collapseTwo" class="panel-collapse collapse in" role="tabpanel" aria-labelledby="headingTwo">
53 53 <div class="panel-body">
54 54 <table class="table table-hover">
55 55 <tr>
56 56 <th>#</th>
57 57 {% for key in configuration_keys %}
58 58 <th>{{ key|title }}</th>
59 59 {% endfor%}
60 60 </tr>
61 61 {% for item in configurations %}
62 62 <tr class="clickable-row" data-href="{{item.get_absolute_url}}">
63 63 <td>{{ forloop.counter }}</td>
64 64 {% for key in configuration_keys %}
65 {% if key == 'device__status' %}
66 <td class="text-{{item.device.status_color}}">{{ item|value:key }}</td>
67 {% else %}
65 68 <td>{{ item|value:key }}</td>
69 {% endif %}
66 70 {% endfor %}
67 71 </tr>
68 72 {% endfor %}
69 73 </table>
70 74 </div>
71 75 </div>
72 76 </div>
73 77 </div>
74 78 {% endblock %}
75 79
76 80 {% block sidebar%}
77 81 {% include "sidebar_devices.html" %}
78 82 {% endblock %}
79 83
80 84 {% block extra-js%}
81 85 <script type="text/javascript">
82 86
83 87 $(".clickable-row").click(function() {
84 88 document.location = $(this).data("href");
85 89 });
86 90
87 91 $("#bt_edit").click(function() {
88 92 document.location = "{% url 'url_edit_experiment' experiment.id%}";
89 93 });
90 94
91 95 $("#bt_add_conf").click(function() {
92 96 document.location = "{% url 'url_add_dev_conf' experiment.id %}";
93 97 });
94 98
95 99 </script>
96 100 {% endblock %} No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,1380 +1,1380
1 1 from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
2 2 from django.utils.safestring import mark_safe
3 3 from django.http import HttpResponseRedirect
4 4 from django.core.urlresolvers import reverse
5 5 from django.contrib import messages
6 6 from datetime import datetime
7 7
8 8 from .forms import CampaignForm, ExperimentForm, DeviceForm, ConfigurationForm, LocationForm, UploadFileForm, DownloadFileForm, OperationForm, NewForm
9 9 from .forms import OperationSearchForm
10 10 from apps.cgs.forms import CGSConfigurationForm
11 11 from apps.jars.forms import JARSConfigurationForm
12 12 from apps.usrp.forms import USRPConfigurationForm
13 13 from apps.abs.forms import ABSConfigurationForm
14 14 from apps.rc.forms import RCConfigurationForm, RCMixConfigurationForm
15 15 from apps.dds.forms import DDSConfigurationForm
16 16
17 17 from .models import Campaign, Experiment, Device, Configuration, Location, RunningExperiment
18 18 from apps.cgs.models import CGSConfiguration
19 19 from apps.jars.models import JARSConfiguration
20 20 from apps.usrp.models import USRPConfiguration
21 21 from apps.abs.models import ABSConfiguration
22 22 from apps.rc.models import RCConfiguration, RCLine, RCLineType
23 23 from apps.dds.models import DDSConfiguration
24 24
25 25 # Create your views here.
26 26
27 27 CONF_FORMS = {
28 28 'rc': RCConfigurationForm,
29 29 'rc_mix': RCMixConfigurationForm,
30 30 'dds': DDSConfigurationForm,
31 31 'jars': JARSConfigurationForm,
32 32 'cgs': CGSConfigurationForm,
33 33 'abs': ABSConfigurationForm,
34 34 'usrp': USRPConfigurationForm,
35 35 }
36 36
37 37 CONF_MODELS = {
38 38 'rc': RCConfiguration,
39 39 'dds': DDSConfiguration,
40 40 'jars': JARSConfiguration,
41 41 'cgs': CGSConfiguration,
42 42 'abs': ABSConfiguration,
43 43 'usrp': USRPConfiguration,
44 44 }
45 45
46 46 MIX_MODES = {
47 47 '0': 'P',
48 48 '1': 'S',
49 49 }
50 50
51 51 MIX_OPERATIONS = {
52 52 '0': 'OR',
53 53 '1': 'XOR',
54 54 '2': 'AND',
55 55 '3': 'NAND',
56 56 }
57 57
58 58
59 59 def index(request):
60 60 kwargs = {}
61 61
62 62 return render(request, 'index.html', kwargs)
63 63
64 64
65 65 def locations(request):
66 66
67 67 locations = Location.objects.all().order_by('name')
68 68
69 69 keys = ['id', 'name', 'description']
70 70
71 71 kwargs = {}
72 72 kwargs['location_keys'] = keys[1:]
73 73 kwargs['locations'] = locations
74 74 kwargs['title'] = 'Location'
75 75 kwargs['suptitle'] = 'List'
76 76 kwargs['button'] = 'New Location'
77 77
78 78 return render(request, 'locations.html', kwargs)
79 79
80 80
81 81 def location(request, id_loc):
82 82
83 83 location = get_object_or_404(Location, pk=id_loc)
84 84
85 85 kwargs = {}
86 86 kwargs['location'] = location
87 87 kwargs['location_keys'] = ['name', 'description']
88 88
89 89 kwargs['title'] = 'Location'
90 90 kwargs['suptitle'] = 'Details'
91 91
92 92 return render(request, 'location.html', kwargs)
93 93
94 94
95 95 def location_new(request):
96 96
97 97 if request.method == 'GET':
98 98 form = LocationForm()
99 99
100 100 if request.method == 'POST':
101 101 form = LocationForm(request.POST)
102 102
103 103 if form.is_valid():
104 104 form.save()
105 105 return redirect('url_locations')
106 106
107 107 kwargs = {}
108 108 kwargs['form'] = form
109 109 kwargs['title'] = 'Location'
110 110 kwargs['suptitle'] = 'New'
111 111 kwargs['button'] = 'Create'
112 112
113 113 return render(request, 'location_edit.html', kwargs)
114 114
115 115
116 116 def location_edit(request, id_loc):
117 117
118 118 location = get_object_or_404(Location, pk=id_loc)
119 119
120 120 if request.method=='GET':
121 121 form = LocationForm(instance=location)
122 122
123 123 if request.method=='POST':
124 124 form = LocationForm(request.POST, instance=location)
125 125
126 126 if form.is_valid():
127 127 form.save()
128 128 return redirect('url_locations')
129 129
130 130 kwargs = {}
131 131 kwargs['form'] = form
132 132 kwargs['title'] = 'Location'
133 133 kwargs['suptitle'] = 'Edit'
134 134 kwargs['button'] = 'Update'
135 135
136 136 return render(request, 'location_edit.html', kwargs)
137 137
138 138
139 139 def location_delete(request, id_loc):
140 140
141 141 location = get_object_or_404(Location, pk=id_loc)
142 142
143 143 if request.method=='POST':
144 144
145 145 if request.user.is_staff:
146 146 location.delete()
147 147 return redirect('url_locations')
148 148
149 149 messages.error(request, 'Not enough permission to delete this object')
150 150 return redirect(location.get_absolute_url())
151 151
152 152 kwargs = {
153 153 'title': 'Delete',
154 154 'suptitle': 'Location',
155 155 'object': location,
156 156 'previous': location.get_absolute_url(),
157 157 'delete': True
158 158 }
159 159
160 160 return render(request, 'confirm.html', kwargs)
161 161
162 162
163 163 def devices(request):
164 164
165 165 devices = Device.objects.all().order_by('device_type__name')
166 166
167 167 # keys = ['id', 'device_type__name', 'name', 'ip_address']
168 168 keys = ['id', 'name', 'ip_address', 'port_address', 'device_type']
169 169
170 170 kwargs = {}
171 171 kwargs['device_keys'] = keys[1:]
172 172 kwargs['devices'] = devices#.values(*keys)
173 173 kwargs['title'] = 'Device'
174 174 kwargs['suptitle'] = 'List'
175 175 kwargs['button'] = 'New Device'
176 176
177 177 return render(request, 'devices.html', kwargs)
178 178
179 179
180 180 def device(request, id_dev):
181 181
182 182 device = get_object_or_404(Device, pk=id_dev)
183 183
184 184 kwargs = {}
185 185 kwargs['device'] = device
186 186 kwargs['device_keys'] = ['device_type', 'name', 'ip_address', 'port_address', 'description']
187 187
188 188 kwargs['title'] = 'Device'
189 189 kwargs['suptitle'] = 'Details'
190 190
191 191 return render(request, 'device.html', kwargs)
192 192
193 193
194 194 def device_new(request):
195 195
196 196 if request.method == 'GET':
197 197 form = DeviceForm()
198 198
199 199 if request.method == 'POST':
200 200 form = DeviceForm(request.POST)
201 201
202 202 if form.is_valid():
203 203 form.save()
204 204 return redirect('url_devices')
205 205
206 206 kwargs = {}
207 207 kwargs['form'] = form
208 208 kwargs['title'] = 'Device'
209 209 kwargs['suptitle'] = 'New'
210 210 kwargs['button'] = 'Create'
211 211
212 212 return render(request, 'device_edit.html', kwargs)
213 213
214 214
215 215 def device_edit(request, id_dev):
216 216
217 217 device = get_object_or_404(Device, pk=id_dev)
218 218
219 219 if request.method=='GET':
220 220 form = DeviceForm(instance=device)
221 221
222 222 if request.method=='POST':
223 223 form = DeviceForm(request.POST, instance=device)
224 224
225 225 if form.is_valid():
226 226 form.save()
227 227 return redirect(device.get_absolute_url())
228 228
229 229 kwargs = {}
230 230 kwargs['form'] = form
231 231 kwargs['title'] = 'Device'
232 232 kwargs['suptitle'] = 'Edit'
233 233 kwargs['button'] = 'Update'
234 234
235 235 return render(request, 'device_edit.html', kwargs)
236 236
237 237
238 238 def device_delete(request, id_dev):
239 239
240 240 device = get_object_or_404(Device, pk=id_dev)
241 241
242 242 if request.method=='POST':
243 243
244 244 if request.user.is_staff:
245 245 device.delete()
246 246 return redirect('url_devices')
247 247
248 248 messages.error(request, 'Not enough permission to delete this object')
249 249 return redirect(device.get_absolute_url())
250 250
251 251 kwargs = {
252 252 'title': 'Delete',
253 253 'suptitle': 'Device',
254 254 'object': device,
255 255 'previous': device.get_absolute_url(),
256 256 'delete': True
257 257 }
258 258
259 259 return render(request, 'confirm.html', kwargs)
260 260
261 261
262 262 def campaigns(request):
263 263
264 264 campaigns = Campaign.objects.all().order_by('start_date')
265 265
266 266 keys = ['id', 'name', 'start_date', 'end_date']
267 267
268 268 kwargs = {}
269 269 kwargs['campaign_keys'] = keys[1:]
270 270 kwargs['campaigns'] = campaigns#.values(*keys)
271 271 kwargs['title'] = 'Campaign'
272 272 kwargs['suptitle'] = 'List'
273 273 kwargs['button'] = 'New Campaign'
274 274
275 275 return render(request, 'campaigns.html', kwargs)
276 276
277 277
278 278 def campaign(request, id_camp):
279 279
280 280 campaign = get_object_or_404(Campaign, pk=id_camp)
281 281 experiments = Experiment.objects.filter(campaign=campaign)
282 282
283 283 form = CampaignForm(instance=campaign)
284 284
285 285 kwargs = {}
286 286 kwargs['campaign'] = campaign
287 287 kwargs['campaign_keys'] = ['template', 'name', 'start_date', 'end_date', 'tags', 'description']
288 288
289 289 kwargs['experiments'] = experiments
290 290 kwargs['experiment_keys'] = ['name', 'radar', 'start_time', 'end_time']
291 291
292 292 kwargs['title'] = 'Campaign'
293 293 kwargs['suptitle'] = 'Details'
294 294
295 295 kwargs['form'] = form
296 296 kwargs['button'] = 'Add Experiment'
297 297
298 298 return render(request, 'campaign.html', kwargs)
299 299
300 300
301 301 def campaign_new(request):
302 302
303 303 kwargs = {}
304 304
305 305 if request.method == 'GET':
306 306
307 307 if 'template' in request.GET:
308 308 if request.GET['template']=='0':
309 309 form = NewForm(initial={'create_from':2},
310 310 template_choices=Campaign.objects.filter(template=True).values_list('id', 'name'))
311 311 else:
312 312 kwargs['button'] = 'Create'
313 313 kwargs['experiments'] = Configuration.objects.filter(experiment=request.GET['template'])
314 314 kwargs['experiment_keys'] = ['name', 'start_time', 'end_time']
315 315 camp = Campaign.objects.get(pk=request.GET['template'])
316 316 form = CampaignForm(instance=camp,
317 317 initial={'name':'{} [{:%Y/%m/%d}]'.format(camp.name, datetime.now()),
318 318 'template':False})
319 319 elif 'blank' in request.GET:
320 320 kwargs['button'] = 'Create'
321 321 form = CampaignForm()
322 322 else:
323 323 form = NewForm()
324 324
325 325 if request.method == 'POST':
326 326 kwargs['button'] = 'Create'
327 327 post = request.POST.copy()
328 328 experiments = []
329 329
330 330 for id_exp in post.getlist('experiments'):
331 331 exp = Experiment.objects.get(pk=id_exp)
332 332 new_exp = exp.clone(template=False)
333 333 experiments.append(new_exp)
334 334
335 335 post.setlist('experiments', [])
336 336
337 337 form = CampaignForm(post)
338 338
339 339 if form.is_valid():
340 340 campaign = form.save()
341 341 for exp in experiments:
342 342 campaign.experiments.add(exp)
343 343 campaign.save()
344 344 return redirect('url_campaign', id_camp=campaign.id)
345 345
346 346 kwargs['form'] = form
347 347 kwargs['title'] = 'Campaign'
348 348 kwargs['suptitle'] = 'New'
349 349
350 350 return render(request, 'campaign_edit.html', kwargs)
351 351
352 352
353 353 def campaign_edit(request, id_camp):
354 354
355 355 campaign = get_object_or_404(Campaign, pk=id_camp)
356 356
357 357 if request.method=='GET':
358 358 form = CampaignForm(instance=campaign)
359 359
360 360 if request.method=='POST':
361 361 exps = campaign.experiments.all().values_list('pk', flat=True)
362 362 post = request.POST.copy()
363 363 new_exps = post.getlist('experiments')
364 364 post.setlist('experiments', [])
365 365 form = CampaignForm(post, instance=campaign)
366 366
367 367 if form.is_valid():
368 368 camp = form.save()
369 369 for id_exp in new_exps:
370 370 if int(id_exp) in exps:
371 371 exps.pop(id_exp)
372 372 else:
373 373 exp = Experiment.objects.get(pk=id_exp)
374 374 if exp.template:
375 375 camp.experiments.add(exp.clone(template=False))
376 376 else:
377 377 camp.experiments.add(exp)
378 378
379 379 for id_exp in exps:
380 380 camp.experiments.remove(Experiment.objects.get(pk=id_exp))
381 381
382 382 return redirect('url_campaign', id_camp=id_camp)
383 383
384 384 kwargs = {}
385 385 kwargs['form'] = form
386 386 kwargs['title'] = 'Campaign'
387 387 kwargs['suptitle'] = 'Edit'
388 388 kwargs['button'] = 'Update'
389 389
390 390 return render(request, 'campaign_edit.html', kwargs)
391 391
392 392
393 393 def campaign_delete(request, id_camp):
394 394
395 395 campaign = get_object_or_404(Campaign, pk=id_camp)
396 396
397 397 if request.method=='POST':
398 398 if request.user.is_staff:
399 399
400 400 for exp in campaign.experiments.all():
401 401 for conf in Configuration.objects.filter(experiment=exp):
402 402 conf.delete()
403 403 exp.delete()
404 404 campaign.delete()
405 405
406 406 return redirect('url_campaigns')
407 407
408 408 messages.error(request, 'Not enough permission to delete this object')
409 409 return redirect(campaign.get_absolute_url())
410 410
411 411 kwargs = {
412 412 'title': 'Delete',
413 413 'suptitle': 'Campaign',
414 414 'object': campaign,
415 415 'previous': campaign.get_absolute_url(),
416 416 'delete': True
417 417 }
418 418
419 419 return render(request, 'confirm.html', kwargs)
420 420
421 421 def campaign_export(request, id_camp):
422 422
423 423 campaign = get_object_or_404(Campaign, pk=id_camp)
424 424 content = campaign.parms_to_dict()
425 425 content_type = 'application/json'
426 426 filename = '%s_%s.json' %(campaign.name, campaign.id)
427 427
428 428 response = HttpResponse(content_type=content_type)
429 429 response['Content-Disposition'] = 'attachment; filename="%s"' %filename
430 430 response.write(content)
431 431
432 432 return response
433 433
434 434
435 435 def campaign_import(request, id_camp):
436 436
437 437 campaign = get_object_or_404(Campaign, pk=id_camp)
438 438
439 439 if request.method == 'GET':
440 440 file_form = UploadFileForm()
441 441
442 442 if request.method == 'POST':
443 443 file_form = UploadFileForm(request.POST, request.FILES)
444 444
445 445 if file_form.is_valid():
446 446
447 447 parms = campaign.import_from_file(request.FILES['file'])
448 448
449 449 if parms:
450 450 parms['name'] = parms['campaign']
451 451
452 452 new_camp = campaign.dict_to_parms(parms, CONF_MODELS)
453 453
454 454 messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name)
455 455
456 456 return redirect(new_camp.get_absolute_url_edit())
457 457
458 458 messages.error(request, "Could not import parameters from file")
459 459
460 460 kwargs = {}
461 461 kwargs['title'] = 'Campaign'
462 462 kwargs['form'] = file_form
463 463 kwargs['suptitle'] = 'Importing file'
464 464 kwargs['button'] = 'Import'
465 465
466 466 return render(request, 'campaign_import.html', kwargs)
467 467
468 468
469 469 def experiments(request):
470 470
471 471 experiment_list = Experiment.objects.all()
472 472
473 473 keys = ['id', 'name', 'start_time', 'end_time']
474 474
475 475 kwargs = {}
476 476
477 477 kwargs['experiment_keys'] = keys[1:]
478 478 kwargs['experiments'] = experiment_list
479 479
480 480 kwargs['title'] = 'Experiment'
481 481 kwargs['suptitle'] = 'List'
482 482 kwargs['button'] = 'New Experiment'
483 483
484 484 return render(request, 'experiments.html', kwargs)
485 485
486 486
487 487 def experiment(request, id_exp):
488 488
489 489 experiment = get_object_or_404(Experiment, pk=id_exp)
490 490
491 491 configurations = Configuration.objects.filter(experiment=experiment, type=0)
492 492
493 493 kwargs = {}
494 494
495 495 kwargs['experiment_keys'] = ['template', 'radar', 'name', 'start_time', 'end_time']
496 496 kwargs['experiment'] = experiment
497 497
498 kwargs['configuration_keys'] = ['name', 'device__device_type', 'device__ip_address', 'device__port_address']
498 kwargs['configuration_keys'] = ['name', 'device__device_type', 'device__ip_address', 'device__port_address', 'device__status']
499 499 kwargs['configurations'] = configurations
500 500
501 501 kwargs['title'] = 'Experiment'
502 502 kwargs['suptitle'] = 'Details'
503 503
504 504 kwargs['button'] = 'Add Configuration'
505 505
506 506 ###### SIDEBAR ######
507 507 kwargs.update(sidebar(experiment=experiment))
508 508
509 509 return render(request, 'experiment.html', kwargs)
510 510
511 511
512 512 def experiment_new(request, id_camp=None):
513 513
514 514 kwargs = {}
515 515
516 516 if request.method == 'GET':
517 517 if 'template' in request.GET:
518 518 if request.GET['template']=='0':
519 519 form = NewForm(initial={'create_from':2},
520 520 template_choices=Experiment.objects.filter(template=True).values_list('id', 'name'))
521 521 else:
522 522 kwargs['button'] = 'Create'
523 523 kwargs['configurations'] = Configuration.objects.filter(experiment=request.GET['template'])
524 524 kwargs['configuration_keys'] = ['name', 'device__name', 'device__ip_address', 'device__port_address']
525 525 exp=Experiment.objects.get(pk=request.GET['template'])
526 526 form = ExperimentForm(instance=exp,
527 527 initial={'name': '{} [{:%Y/%m/%d}]'.format(exp.name, datetime.now()),
528 528 'template': False})
529 529 elif 'blank' in request.GET:
530 530 kwargs['button'] = 'Create'
531 531 form = ExperimentForm()
532 532 else:
533 533 form = NewForm()
534 534
535 535 if request.method == 'POST':
536 536 form = ExperimentForm(request.POST)
537 537 if form.is_valid():
538 538 experiment = form.save()
539 539
540 540 if 'template' in request.GET:
541 541 configurations = Configuration.objects.filter(experiment=request.GET['template'], type=0)
542 542 for conf in configurations:
543 543 conf.clone(experiment=experiment, template=False)
544 544
545 545 return redirect('url_experiment', id_exp=experiment.id)
546 546
547 547 kwargs['form'] = form
548 548 kwargs['title'] = 'Experiment'
549 549 kwargs['suptitle'] = 'New'
550 550
551 551 return render(request, 'experiment_edit.html', kwargs)
552 552
553 553
554 554 def experiment_edit(request, id_exp):
555 555
556 556 experiment = get_object_or_404(Experiment, pk=id_exp)
557 557
558 558 if request.method == 'GET':
559 559 form = ExperimentForm(instance=experiment)
560 560
561 561 if request.method=='POST':
562 562 form = ExperimentForm(request.POST, instance=experiment)
563 563
564 564 if form.is_valid():
565 565 experiment = form.save()
566 566 return redirect('url_experiment', id_exp=experiment.id)
567 567
568 568 kwargs = {}
569 569 kwargs['form'] = form
570 570 kwargs['title'] = 'Experiment'
571 571 kwargs['suptitle'] = 'Edit'
572 572 kwargs['button'] = 'Update'
573 573
574 574 return render(request, 'experiment_edit.html', kwargs)
575 575
576 576
577 577 def experiment_delete(request, id_exp):
578 578
579 579 experiment = get_object_or_404(Experiment, pk=id_exp)
580 580
581 581 if request.method=='POST':
582 582 if request.user.is_staff:
583 583 for conf in Configuration.objects.filter(experiment=experiment):
584 584 conf.delete()
585 585 experiment.delete()
586 586 return redirect('url_experiments')
587 587
588 588 messages.error(request, 'Not enough permission to delete this object')
589 589 return redirect(experiment.get_absolute_url())
590 590
591 591 kwargs = {
592 592 'title': 'Delete',
593 593 'suptitle': 'Experiment',
594 594 'object': experiment,
595 595 'previous': experiment.get_absolute_url(),
596 596 'delete': True
597 597 }
598 598
599 599 return render(request, 'confirm.html', kwargs)
600 600
601 601
602 602 def experiment_export(request, id_exp):
603 603
604 604 experiment = get_object_or_404(Experiment, pk=id_exp)
605 605 content = experiment.parms_to_dict()
606 606 content_type = 'application/json'
607 607 filename = '%s_%s.json' %(experiment.name, experiment.id)
608 608
609 609 response = HttpResponse(content_type=content_type)
610 610 response['Content-Disposition'] = 'attachment; filename="%s"' %filename
611 611 response.write(content)
612 612
613 613 return response
614 614
615 615 def experiment_import(request, id_exp):
616 616
617 617 experiment = get_object_or_404(Experiment, pk=id_exp)
618 618 configurations = Configuration.objects.filter(experiment=experiment)
619 619
620 620 if request.method == 'GET':
621 621 file_form = UploadFileForm()
622 622
623 623 if request.method == 'POST':
624 624 file_form = UploadFileForm(request.POST, request.FILES)
625 625
626 626 if file_form.is_valid():
627 627
628 628 parms = experiment.import_from_file(request.FILES['file'])
629 629
630 630 if parms:
631 631
632 632 new_exp = experiment.dict_to_parms(parms, CONF_MODELS)
633 633
634 634 messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name)
635 635
636 636 return redirect(new_exp.get_absolute_url_edit())
637 637
638 638 messages.error(request, "Could not import parameters from file")
639 639
640 640 kwargs = {}
641 641 kwargs['title'] = 'Experiment'
642 642 kwargs['form'] = file_form
643 643 kwargs['suptitle'] = 'Importing file'
644 644 kwargs['button'] = 'Import'
645 645
646 646 kwargs.update(sidebar(experiment=experiment))
647 647
648 648 return render(request, 'experiment_import.html', kwargs)
649 649
650 650 def experiment_mix(request, id_exp):
651 651
652 652 experiment = get_object_or_404(Experiment, pk=id_exp)
653 653 rc_confs = [conf for conf in RCConfiguration.objects.filter(experiment=id_exp,
654 654 mix=False)]
655 655
656 656 if len(rc_confs)<2:
657 657 messages.warning(request, 'You need at least two RC Configurations to make a mix')
658 658 return redirect(experiment.get_absolute_url())
659 659
660 660 mix_confs = RCConfiguration.objects.filter(experiment=id_exp, mix=True)
661 661
662 662 if mix_confs:
663 663 mix = mix_confs[0]
664 664 else:
665 665 mix = RCConfiguration(experiment=experiment,
666 666 device=rc_confs[0].device,
667 667 ipp=rc_confs[0].ipp,
668 668 clock_in=rc_confs[0].clock_in,
669 669 clock_divider=rc_confs[0].clock_divider,
670 670 mix=True,
671 671 parameters='')
672 672 mix.save()
673 673
674 674 line_type = RCLineType.objects.get(name='mix')
675 675 for i in range(len(rc_confs[0].get_lines())):
676 676 line = RCLine(rc_configuration=mix, line_type=line_type, channel=i)
677 677 line.save()
678 678
679 679 initial = {'name': mix.name,
680 680 'result': parse_mix_result(mix.parameters),
681 681 'delay': 0,
682 682 'mask': [0,1,2,3,4,5,6,7]
683 683 }
684 684
685 685 if request.method=='GET':
686 686 form = RCMixConfigurationForm(confs=rc_confs, initial=initial)
687 687
688 688 if request.method=='POST':
689 689 result = mix.parameters
690 690
691 691 if '{}|'.format(request.POST['experiment']) in result:
692 692 messages.error(request, 'Configuration already added')
693 693 else:
694 694 if 'operation' in request.POST:
695 695 operation = MIX_OPERATIONS[request.POST['operation']]
696 696 else:
697 697 operation = ' '
698 698
699 699 mode = MIX_MODES[request.POST['mode']]
700 700
701 701 if result:
702 702 result = '{}-{}|{}|{}|{}|{}'.format(mix.parameters,
703 703 request.POST['experiment'],
704 704 mode,
705 705 operation,
706 706 float(request.POST['delay']),
707 707 parse_mask(request.POST.getlist('mask'))
708 708 )
709 709 else:
710 710 result = '{}|{}|{}|{}|{}'.format(request.POST['experiment'],
711 711 mode,
712 712 operation,
713 713 float(request.POST['delay']),
714 714 parse_mask(request.POST.getlist('mask'))
715 715 )
716 716
717 717 mix.parameters = result
718 718 mix.name = request.POST['name']
719 719 mix.save()
720 720 mix.update_pulses()
721 721
722 722 initial['result'] = parse_mix_result(result)
723 723 initial['name'] = mix.name
724 724
725 725 form = RCMixConfigurationForm(initial=initial, confs=rc_confs)
726 726
727 727
728 728 kwargs = {
729 729 'title': 'Experiment',
730 730 'suptitle': 'Mix Configurations',
731 731 'form' : form,
732 732 'extra_button': 'Delete',
733 733 'button': 'Add',
734 734 'cancel': 'Back',
735 735 'previous': experiment.get_absolute_url(),
736 736 'id_exp':id_exp,
737 737
738 738 }
739 739
740 740 return render(request, 'experiment_mix.html', kwargs)
741 741
742 742
743 743 def experiment_mix_delete(request, id_exp):
744 744
745 745 conf = RCConfiguration.objects.get(experiment=id_exp, mix=True)
746 746 values = conf.parameters.split('-')
747 747 conf.parameters = '-'.join(values[:-1])
748 748 conf.save()
749 749
750 750 return redirect('url_mix_experiment', id_exp=id_exp)
751 751
752 752
753 753 def parse_mix_result(s):
754 754
755 755 values = s.split('-')
756 756 html = 'EXP MOD OPE DELAY MASK\r\n'
757 757
758 758 if not values or values[0] in ('', ' '):
759 759 return mark_safe(html)
760 760
761 761 for i, value in enumerate(values):
762 762 if not value:
763 763 continue
764 764 pk, mode, operation, delay, mask = value.split('|')
765 765 conf = RCConfiguration.objects.get(pk=pk)
766 766 if i==0:
767 767 html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format(
768 768 conf.name,
769 769 mode,
770 770 ' ',
771 771 delay,
772 772 mask)
773 773 else:
774 774 html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format(
775 775 conf.name,
776 776 mode,
777 777 operation,
778 778 delay,
779 779 mask)
780 780
781 781 return mark_safe(html)
782 782
783 783 def parse_mask(l):
784 784
785 785 values = []
786 786
787 787 for x in range(8):
788 788 if '{}'.format(x) in l:
789 789 values.append(1)
790 790 else:
791 791 values.append(0)
792 792
793 793 values.reverse()
794 794
795 795 return int(''.join([str(x) for x in values]), 2)
796 796
797 797
798 798 def dev_confs(request):
799 799
800 800 configurations = Configuration.objects.all().order_by('type', 'device__device_type', 'experiment')
801 801
802 802 kwargs = {}
803 803
804 804 kwargs['configuration_keys'] = ['device', 'name', 'experiment', 'type', 'programmed_date']
805 805 kwargs['configurations'] = configurations
806 806
807 807 kwargs['title'] = 'Configuration'
808 808 kwargs['suptitle'] = 'List'
809 809
810 810 return render(request, 'dev_confs.html', kwargs)
811 811
812 812
813 813 def dev_conf(request, id_conf):
814 814
815 815 conf = get_object_or_404(Configuration, pk=id_conf)
816 816
817 817 return redirect(conf.get_absolute_url())
818 818
819 819
820 820 def dev_conf_new(request, id_exp=0, id_dev=0):
821 821
822 822 initial = {}
823 823 kwargs = {}
824 824
825 825 if id_exp<>0:
826 826 initial['experiment'] = id_exp
827 827
828 828 if id_dev<>0:
829 829 initial['device'] = id_dev
830 830
831 831 if request.method == 'GET':
832 832
833 833 if id_dev:
834 834 kwargs['button'] = 'Create'
835 835 device = Device.objects.get(pk=id_dev)
836 836 DevConfForm = CONF_FORMS[device.device_type.name]
837 837 initial['name'] = request.GET['name']
838 838 form = DevConfForm(initial=initial)
839 839 else:
840 840 if 'template' in request.GET:
841 841 if request.GET['template']=='0':
842 842 form = NewForm(initial={'create_from':2},
843 843 template_choices=Configuration.objects.filter(template=True).values_list('id', 'name'))
844 844 else:
845 845 kwargs['button'] = 'Create'
846 846 conf = Configuration.objects.get(pk=request.GET['template'])
847 847 id_dev = conf.device.pk
848 848 DevConfForm = CONF_FORMS[conf.device.device_type.name]
849 849 form = DevConfForm(instance=conf,
850 850 initial={'name': '{} [{:%Y/%m/%d}]'.format(conf.name, datetime.now()),
851 851 'template': False,
852 852 'experiment':id_exp})
853 853 elif 'blank' in request.GET:
854 854 kwargs['button'] = 'Create'
855 855 form = ConfigurationForm(initial=initial)
856 856 else:
857 857 form = NewForm()
858 858
859 859 if request.method == 'POST':
860 860
861 861 device = Device.objects.get(pk=request.POST['device'])
862 862 DevConfForm = CONF_FORMS[device.device_type.name]
863 863
864 864 form = DevConfForm(request.POST)
865 865
866 866 if form.is_valid():
867 867 conf = form.save()
868 868
869 869 if 'template' in request.GET and conf.device.device_type.name=='rc':
870 870 lines = RCLine.objects.filter(rc_configuration=request.GET['template'])
871 871 for line in lines:
872 872 line.clone(rc_configuration=conf)
873 873
874 874 return redirect('url_dev_conf', id_conf=conf.pk)
875 875
876 876
877 877 kwargs['id_exp'] = id_exp
878 878 kwargs['form'] = form
879 879 kwargs['title'] = 'Configuration'
880 880 kwargs['suptitle'] = 'New'
881 881
882 882
883 883 if id_dev != 0:
884 884 device = Device.objects.get(pk=id_dev)
885 885 kwargs['device'] = device.device_type.name
886 886
887 887 return render(request, 'dev_conf_edit.html', kwargs)
888 888
889 889
890 890 def dev_conf_edit(request, id_conf):
891 891
892 892 conf = get_object_or_404(Configuration, pk=id_conf)
893 893
894 894 DevConfModel = CONF_MODELS[conf.device.device_type.name]
895 895 DevConfForm = CONF_FORMS[conf.device.device_type.name]
896 896
897 897 dev_conf = DevConfModel.objects.get(pk=id_conf)
898 898
899 899 if request.method=='GET':
900 900 form = DevConfForm(instance=dev_conf)
901 901
902 902 if request.method=='POST':
903 903 form = DevConfForm(request.POST, instance=dev_conf)
904 904
905 905 if form.is_valid():
906 906 form.save()
907 907 return redirect('url_dev_conf', id_conf=id_conf)
908 908
909 909 kwargs = {}
910 910 kwargs['form'] = form
911 911 kwargs['title'] = 'Device Configuration'
912 912 kwargs['suptitle'] = 'Edit'
913 913 kwargs['button'] = 'Update'
914 914
915 915 ###### SIDEBAR ######
916 916 kwargs.update(sidebar(conf=conf))
917 917
918 918 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
919 919
920 920
921 921 def dev_conf_start(request, id_conf):
922 922
923 923 conf = get_object_or_404(Configuration, pk=id_conf)
924 924
925 925 DevConfModel = CONF_MODELS[conf.device.device_type.name]
926 926
927 927 conf = DevConfModel.objects.get(pk=id_conf)
928 928
929 929 if conf.start_device():
930 930 messages.success(request, conf.message)
931 931 else:
932 932 messages.error(request, conf.message)
933 933
934 934 conf.status_device()
935 935
936 936 return redirect(conf.get_absolute_url())
937 937
938 938
939 939 def dev_conf_stop(request, id_conf):
940 940
941 941 conf = get_object_or_404(Configuration, pk=id_conf)
942 942
943 943 DevConfModel = CONF_MODELS[conf.device.device_type.name]
944 944
945 945 conf = DevConfModel.objects.get(pk=id_conf)
946 946
947 947 if conf.stop_device():
948 948 messages.success(request, conf.message)
949 949 else:
950 950 messages.error(request, conf.message)
951 951
952 952 conf.status_device()
953 953
954 954 return redirect(conf.get_absolute_url())
955 955
956 956
957 957 def dev_conf_status(request, id_conf):
958 958
959 959 conf = get_object_or_404(Configuration, pk=id_conf)
960 960
961 961 DevConfModel = CONF_MODELS[conf.device.device_type.name]
962 962
963 963 conf = DevConfModel.objects.get(pk=id_conf)
964 964
965 965 if conf.status_device():
966 966 messages.success(request, conf.message)
967 967 else:
968 968 messages.error(request, conf.message)
969 969
970 970 return redirect(conf.get_absolute_url())
971 971
972 972
973 973 def dev_conf_write(request, id_conf):
974 974
975 975 conf = get_object_or_404(Configuration, pk=id_conf)
976 976
977 977 DevConfModel = CONF_MODELS[conf.device.device_type.name]
978 978
979 979 conf = DevConfModel.objects.get(pk=id_conf)
980 980
981 981 answer = conf.write_device()
982 982 conf.status_device()
983 983
984 984 if answer:
985 985 messages.success(request, conf.message)
986 986
987 987 #Creating a historical configuration
988 988 conf.clone(type=0, template=False)
989 989
990 990 #Original configuration
991 991 conf = DevConfModel.objects.get(pk=id_conf)
992 992 else:
993 993 messages.error(request, conf.message)
994 994
995 995 return redirect(conf.get_absolute_url())
996 996
997 997
998 998 def dev_conf_read(request, id_conf):
999 999
1000 1000 conf = get_object_or_404(Configuration, pk=id_conf)
1001 1001
1002 1002 DevConfModel = CONF_MODELS[conf.device.device_type.name]
1003 1003 DevConfForm = CONF_FORMS[conf.device.device_type.name]
1004 1004
1005 1005 conf = DevConfModel.objects.get(pk=id_conf)
1006 1006
1007 1007 if request.method=='GET':
1008 1008
1009 1009 parms = conf.read_device()
1010 1010 conf.status_device()
1011 1011
1012 1012 if not parms:
1013 1013 messages.error(request, conf.message)
1014 1014 return redirect(conf.get_absolute_url())
1015 1015
1016 1016 form = DevConfForm(initial=parms, instance=conf)
1017 1017
1018 1018 if request.method=='POST':
1019 1019 form = DevConfForm(request.POST, instance=conf)
1020 1020
1021 1021 if form.is_valid():
1022 1022 form.save()
1023 1023 return redirect(conf.get_absolute_url())
1024 1024
1025 1025 messages.error(request, "Parameters could not be saved")
1026 1026
1027 1027 kwargs = {}
1028 1028 kwargs['id_dev'] = conf.id
1029 1029 kwargs['form'] = form
1030 1030 kwargs['title'] = 'Device Configuration'
1031 1031 kwargs['suptitle'] = 'Parameters read from device'
1032 1032 kwargs['button'] = 'Save'
1033 1033
1034 1034 ###### SIDEBAR ######
1035 1035 kwargs.update(sidebar(conf=conf))
1036 1036
1037 1037 return render(request, '%s_conf_edit.html' %conf.device.device_type.name, kwargs)
1038 1038
1039 1039
1040 1040 def dev_conf_import(request, id_conf):
1041 1041
1042 1042 conf = get_object_or_404(Configuration, pk=id_conf)
1043 1043
1044 1044 DevConfModel = CONF_MODELS[conf.device.device_type.name]
1045 1045 DevConfForm = CONF_FORMS[conf.device.device_type.name]
1046 1046 conf = DevConfModel.objects.get(pk=id_conf)
1047 1047
1048 1048 if request.method == 'GET':
1049 1049 file_form = UploadFileForm()
1050 1050
1051 1051 if request.method == 'POST':
1052 1052 file_form = UploadFileForm(request.POST, request.FILES)
1053 1053
1054 1054 if file_form.is_valid():
1055 1055
1056 1056 parms = conf.import_from_file(request.FILES['file'])
1057 1057
1058 1058 if parms:
1059 1059 messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name)
1060 1060 form = DevConfForm(initial=parms, instance=conf)
1061 1061
1062 1062 kwargs = {}
1063 1063 kwargs['id_dev'] = conf.id
1064 1064 kwargs['form'] = form
1065 1065 kwargs['title'] = 'Device Configuration'
1066 1066 kwargs['suptitle'] = 'Parameters imported'
1067 1067 kwargs['button'] = 'Save'
1068 1068 kwargs['action'] = conf.get_absolute_url_edit()
1069 1069 kwargs['previous'] = conf.get_absolute_url()
1070 1070
1071 1071 ###### SIDEBAR ######
1072 1072 kwargs.update(sidebar(conf=conf))
1073 1073
1074 1074 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
1075 1075
1076 1076 messages.error(request, "Could not import parameters from file")
1077 1077
1078 1078 kwargs = {}
1079 1079 kwargs['id_dev'] = conf.id
1080 1080 kwargs['title'] = 'Device Configuration'
1081 1081 kwargs['form'] = file_form
1082 1082 kwargs['suptitle'] = 'Importing file'
1083 1083 kwargs['button'] = 'Import'
1084 1084
1085 1085 kwargs.update(sidebar(conf=conf))
1086 1086
1087 1087 return render(request, 'dev_conf_import.html', kwargs)
1088 1088
1089 1089
1090 1090 def dev_conf_export(request, id_conf):
1091 1091
1092 1092 conf = get_object_or_404(Configuration, pk=id_conf)
1093 1093
1094 1094 DevConfModel = CONF_MODELS[conf.device.device_type.name]
1095 1095
1096 1096 conf = DevConfModel.objects.get(pk=id_conf)
1097 1097
1098 1098 if request.method == 'GET':
1099 1099 file_form = DownloadFileForm(conf.device.device_type.name)
1100 1100
1101 1101 if request.method == 'POST':
1102 1102 file_form = DownloadFileForm(conf.device.device_type.name, request.POST)
1103 1103
1104 1104 if file_form.is_valid():
1105 1105 fields = conf.export_to_file(format = file_form.cleaned_data['format'])
1106 1106
1107 1107 response = HttpResponse(content_type=fields['content_type'])
1108 1108 response['Content-Disposition'] = 'attachment; filename="%s"' %fields['filename']
1109 1109 response.write(fields['content'])
1110 1110
1111 1111 return response
1112 1112
1113 1113 messages.error(request, "Could not export parameters")
1114 1114
1115 1115 kwargs = {}
1116 1116 kwargs['id_dev'] = conf.id
1117 1117 kwargs['title'] = 'Device Configuration'
1118 1118 kwargs['form'] = file_form
1119 1119 kwargs['suptitle'] = 'Exporting file'
1120 1120 kwargs['button'] = 'Export'
1121 1121
1122 1122 return render(request, 'dev_conf_export.html', kwargs)
1123 1123
1124 1124
1125 1125 def dev_conf_delete(request, id_conf):
1126 1126
1127 1127 conf = get_object_or_404(Configuration, pk=id_conf)
1128 1128
1129 1129 if request.method=='POST':
1130 1130 if request.user.is_staff:
1131 1131 conf.delete()
1132 1132 return redirect('url_dev_confs')
1133 1133
1134 1134 messages.error(request, 'Not enough permission to delete this object')
1135 1135 return redirect(conf.get_absolute_url())
1136 1136
1137 1137 kwargs = {
1138 1138 'title': 'Delete',
1139 1139 'suptitle': 'Experiment',
1140 1140 'object': conf,
1141 1141 'previous': conf.get_absolute_url(),
1142 1142 'delete': True
1143 1143 }
1144 1144
1145 1145 return render(request, 'confirm.html', kwargs)
1146 1146
1147 1147
1148 1148 def sidebar(**kwargs):
1149 1149
1150 1150 side_data = {}
1151 1151
1152 1152 conf = kwargs.get('conf', None)
1153 1153 experiment = kwargs.get('experiment', None)
1154 1154
1155 1155 if not experiment:
1156 1156 experiment = conf.experiment
1157 1157
1158 1158 if experiment:
1159 1159 side_data['experiment'] = experiment
1160 1160 campaign = experiment.campaign_set.all()
1161 1161 if campaign:
1162 1162 side_data['campaign'] = campaign[0]
1163 1163 experiments = campaign[0].experiments.all()
1164 1164 else:
1165 1165 experiments = [experiment]
1166 1166 configurations = experiment.configuration_set.filter(type=0)
1167 1167 side_data['side_experiments'] = experiments
1168 1168 side_data['side_configurations'] = configurations
1169 1169
1170 1170 return side_data
1171 1171
1172 1172
1173 1173 def operation(request, id_camp=None):
1174 1174
1175 1175 if not id_camp:
1176 1176 campaigns = Campaign.objects.all().order_by('-start_date')
1177 1177
1178 1178 if not campaigns:
1179 1179 kwargs = {}
1180 1180 kwargs['title'] = 'No Campaigns'
1181 1181 kwargs['suptitle'] = 'Empty'
1182 1182 return render(request, 'operation.html', kwargs)
1183 1183
1184 1184 id_camp = campaigns[0].id
1185 1185
1186 1186 campaign = get_object_or_404(Campaign, pk = id_camp)
1187 1187
1188 1188 if request.method=='GET':
1189 1189 form = OperationForm(initial={'campaign': campaign.id}, length = 5)
1190 1190
1191 1191 if request.method=='POST':
1192 1192 form = OperationForm(request.POST, initial={'campaign':campaign.id}, length = 5)
1193 1193
1194 1194 if form.is_valid():
1195 1195 return redirect('url_operation', id_camp=campaign.id)
1196 1196 #locations = Location.objects.filter(experiment__campaign__pk = campaign.id).distinct()
1197 1197 experiments = Experiment.objects.filter(campaign__pk=campaign.id)
1198 1198 #for exs in experiments:
1199 1199 # exs.get_status()
1200 1200 locations= Location.objects.filter(experiment=experiments).distinct()
1201 1201 #experiments = [Experiment.objects.filter(location__pk=location.id).filter(campaign__pk=campaign.id) for location in locations]
1202 1202 kwargs = {}
1203 1203 #---Campaign
1204 1204 kwargs['campaign'] = campaign
1205 1205 kwargs['campaign_keys'] = ['name', 'start_date', 'end_date', 'tags', 'description']
1206 1206 #---Experiment
1207 1207 keys = ['id', 'name', 'start_time', 'end_time', 'status']
1208 1208 kwargs['experiment_keys'] = keys[1:]
1209 1209 kwargs['experiments'] = experiments
1210 1210 #---Radar
1211 1211 kwargs['locations'] = locations
1212 1212 #---Else
1213 1213 kwargs['title'] = 'Campaign'
1214 1214 kwargs['suptitle'] = campaign.name
1215 1215 kwargs['form'] = form
1216 1216 kwargs['button'] = 'Search'
1217 1217 kwargs['details'] = True
1218 1218 kwargs['search_button'] = True
1219 1219
1220 1220 return render(request, 'operation.html', kwargs)
1221 1221
1222 1222
1223 1223 def operation_search(request, id_camp=None):
1224 1224
1225 1225
1226 1226 if not id_camp:
1227 1227 campaigns = Campaign.objects.all().order_by('-start_date')
1228 1228
1229 1229 if not campaigns:
1230 1230 return render(request, 'operation.html', {})
1231 1231
1232 1232 id_camp = campaigns[0].id
1233 1233 campaign = get_object_or_404(Campaign, pk = id_camp)
1234 1234
1235 1235 if request.method=='GET':
1236 1236 form = OperationSearchForm(initial={'campaign': campaign.id})
1237 1237
1238 1238 if request.method=='POST':
1239 1239 form = OperationSearchForm(request.POST, initial={'campaign':campaign.id})
1240 1240
1241 1241 if form.is_valid():
1242 1242 return redirect('url_operation', id_camp=campaign.id)
1243 1243
1244 1244 #locations = Location.objects.filter(experiment__campaign__pk = campaign.id).distinct()
1245 1245 experiments = Experiment.objects.filter(campaign__pk=campaign.id)
1246 1246 #for exs in experiments:
1247 1247 # exs.get_status()
1248 1248 locations= Location.objects.filter(experiment=experiments).distinct()
1249 1249 form = OperationSearchForm(initial={'campaign': campaign.id})
1250 1250
1251 1251 kwargs = {}
1252 1252 #---Campaign
1253 1253 kwargs['campaign'] = campaign
1254 1254 kwargs['campaign_keys'] = ['name', 'start_date', 'end_date', 'tags', 'description']
1255 1255 #---Experiment
1256 1256 keys = ['id', 'name', 'start_time', 'end_time', 'status']
1257 1257 kwargs['experiment_keys'] = keys[1:]
1258 1258 kwargs['experiments'] = experiments
1259 1259 #---Radar
1260 1260 kwargs['locations'] = locations
1261 1261 #---Else
1262 1262 kwargs['title'] = 'Campaign'
1263 1263 kwargs['suptitle'] = campaign.name
1264 1264 kwargs['form'] = form
1265 1265 kwargs['button'] = 'Select'
1266 1266 kwargs['details'] = True
1267 1267 kwargs['search_button'] = False
1268 1268
1269 1269 return render(request, 'operation.html', kwargs)
1270 1270
1271 1271
1272 1272 def radar_play(request, id_camp, id_radar):
1273 1273 campaign = get_object_or_404(Campaign, pk = id_camp)
1274 1274 radar = get_object_or_404(Location, pk = id_radar)
1275 1275 today = datetime.today()
1276 1276 now = today.time()
1277 1277
1278 1278 #--Clear Old Experiments From RunningExperiment Object
1279 1279 running_experiment = RunningExperiment.objects.filter(radar=radar)
1280 1280 if running_experiment:
1281 1281 running_experiment = running_experiment[0]
1282 1282 running_experiment.running_experiment.clear()
1283 1283 running_experiment.save()
1284 1284
1285 1285 #--If campaign datetime is ok:
1286 1286 if today >= campaign.start_date and today <= campaign.end_date:
1287 1287 experiments = Experiment.objects.filter(campaign=campaign).filter(location=radar)
1288 1288 for exp in experiments:
1289 1289 #--If experiment time is ok:
1290 1290 if now >= exp.start_time and now <= exp.end_time:
1291 1291 configurations = Configuration.objects.filter(experiment = exp)
1292 1292 for conf in configurations:
1293 1293 if 'cgs' in conf.device.device_type.name:
1294 1294 conf.status_device()
1295 1295 else:
1296 1296 answer = conf.start_device()
1297 1297 conf.status_device()
1298 1298 #--Running Experiment
1299 1299 old_running_experiment = RunningExperiment.objects.filter(radar=radar)
1300 1300 #--If RunningExperiment element exists
1301 1301 if old_running_experiment:
1302 1302 old_running_experiment = old_running_experiment[0]
1303 1303 old_running_experiment.running_experiment.add(exp)
1304 1304 old_running_experiment.status = 3
1305 1305 old_running_experiment.save()
1306 1306 #--Create a new Running_Experiment Object
1307 1307 else:
1308 1308 new_running_experiment = RunningExperiment(
1309 1309 radar = radar,
1310 1310 status = 3,
1311 1311 )
1312 1312 new_running_experiment.save()
1313 1313 new_running_experiment.running_experiment.add(exp)
1314 1314 new_running_experiment.save()
1315 1315
1316 1316 if answer:
1317 1317 messages.success(request, conf.message)
1318 1318 exp.status=2
1319 1319 exp.save()
1320 1320 else:
1321 1321 messages.error(request, conf.message)
1322 1322 else:
1323 1323 if exp.status == 1 or exp.status == 3:
1324 1324 exp.status=3
1325 1325 exp.save()
1326 1326
1327 1327
1328 1328 route = request.META['HTTP_REFERER']
1329 1329 route = str(route)
1330 1330 if 'search' in route:
1331 1331 return HttpResponseRedirect(reverse('url_operation_search', args=[id_camp]))
1332 1332 else:
1333 1333 return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
1334 1334
1335 1335
1336 1336 def radar_stop(request, id_camp, id_radar):
1337 1337 campaign = get_object_or_404(Campaign, pk = id_camp)
1338 1338 radar = get_object_or_404(Location, pk = id_radar)
1339 1339 experiments = Experiment.objects.filter(campaign=campaign).filter(location=radar)
1340 1340
1341 1341 for exp in experiments:
1342 1342 configurations = Configuration.objects.filter(experiment = exp)
1343 1343 for conf in configurations:
1344 1344 if 'cgs' in conf.device.device_type.name:
1345 1345 conf.status_device()
1346 1346 else:
1347 1347 answer = conf.stop_device()
1348 1348 conf.status_device()
1349 1349
1350 1350 if answer:
1351 1351 messages.success(request, conf.message)
1352 1352 exp.status=1
1353 1353 exp.save()
1354 1354 else:
1355 1355 messages.error(request, conf.message)
1356 1356
1357 1357
1358 1358 route = request.META['HTTP_REFERER']
1359 1359 route = str(route)
1360 1360 if 'search' in route:
1361 1361 return HttpResponseRedirect(reverse('url_operation_search', args=[id_camp]))
1362 1362 else:
1363 1363 return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
1364 1364
1365 1365
1366 1366 def radar_refresh(request, id_camp, id_radar):
1367 1367
1368 1368 campaign = get_object_or_404(Campaign, pk = id_camp)
1369 1369 radar = get_object_or_404(Location, pk = id_radar)
1370 1370 experiments = Experiment.objects.filter(campaign=campaign).filter(location=radar)
1371 1371 for exs in experiments:
1372 1372 exs.get_status()
1373 1373
1374 1374 route = request.META['HTTP_REFERER']
1375 1375 route = str(route)
1376 1376 if 'search' in route:
1377 1377 return HttpResponseRedirect(reverse('url_operation_search', args=[id_camp]))
1378 1378 else:
1379 1379 return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
1380 1380
General Comments 0
You need to be logged in to leave comments. Login now