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