##// END OF EJS Templates
radarsys_met
RSS
task for monitoring devices status from experiment...
Fiorella Quino -
r254:e4d44fca0b72
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1663 +1,1665
1 1 import ast
2 2 import json
3 3 from datetime import datetime
4 4
5 5 from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
6 6 from django.utils.safestring import mark_safe
7 7 from django.http import HttpResponseRedirect
8 8 from django.core.urlresolvers import reverse
9 9 from django.db.models import Q
10 10 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
11 11 from django.contrib import messages
12 12 from django.http.request import QueryDict
13 13
14 14 try:
15 15 from urllib.parse import urlencode
16 16 except ImportError:
17 17 from urllib import urlencode
18 18
19 19 from .forms import CampaignForm, ExperimentForm, DeviceForm, ConfigurationForm, LocationForm, UploadFileForm, DownloadFileForm, OperationForm, NewForm
20 20 from .forms import OperationSearchForm, FilterForm, ChangeIpForm
21 21
22 from .tasks import task_start, task_stop
22 from .tasks import task_start, task_stop, task_status
23 23
24 24 from apps.rc.forms import RCConfigurationForm, RCLineCode, RCMixConfigurationForm
25 25 from apps.dds.forms import DDSConfigurationForm
26 26 from apps.jars.forms import JARSConfigurationForm
27 27 from apps.cgs.forms import CGSConfigurationForm
28 28 from apps.abs.forms import ABSConfigurationForm
29 29 from apps.usrp.forms import USRPConfigurationForm
30 30
31 31 from .models import Campaign, Experiment, Device, Configuration, Location, RunningExperiment, DEV_STATES
32 32 from apps.cgs.models import CGSConfiguration
33 33 from apps.jars.models import JARSConfiguration, EXPERIMENT_TYPE
34 34 from apps.usrp.models import USRPConfiguration
35 35 from apps.abs.models import ABSConfiguration
36 36 from apps.rc.models import RCConfiguration, RCLine, RCLineType
37 37 from apps.dds.models import DDSConfiguration
38 38
39 39 from django.contrib.auth.decorators import login_required
40 40 from django.contrib.auth.decorators import user_passes_test
41 41 from django.contrib.admin.views.decorators import staff_member_required
42 42
43 43 CONF_FORMS = {
44 44 'rc': RCConfigurationForm,
45 45 'dds': DDSConfigurationForm,
46 46 'jars': JARSConfigurationForm,
47 47 'cgs': CGSConfigurationForm,
48 48 'abs': ABSConfigurationForm,
49 49 'usrp': USRPConfigurationForm,
50 50 }
51 51
52 52 CONF_MODELS = {
53 53 'rc': RCConfiguration,
54 54 'dds': DDSConfiguration,
55 55 'jars': JARSConfiguration,
56 56 'cgs': CGSConfiguration,
57 57 'abs': ABSConfiguration,
58 58 'usrp': USRPConfiguration,
59 59 }
60 60
61 61 MIX_MODES = {
62 62 '0': 'P',
63 63 '1': 'S',
64 64 }
65 65
66 66 MIX_OPERATIONS = {
67 67 '0': 'OR',
68 68 '1': 'XOR',
69 69 '2': 'AND',
70 70 '3': 'NAND',
71 71 }
72 72
73 73 def index(request):
74 74 kwargs = {'no_sidebar':True}
75 75
76 76 return render(request, 'index.html', kwargs)
77 77
78 78
79 79 def locations(request):
80 80
81 81 page = request.GET.get('page')
82 82 order = ('name',)
83 83
84 84 kwargs = get_paginator(Location, page, order)
85 85
86 86 kwargs['keys'] = ['name', 'description']
87 87 kwargs['title'] = 'Radar System'
88 88 kwargs['suptitle'] = 'List'
89 89 kwargs['no_sidebar'] = True
90 90
91 91 return render(request, 'base_list.html', kwargs)
92 92
93 93
94 94 def location(request, id_loc):
95 95
96 96 location = get_object_or_404(Location, pk=id_loc)
97 97
98 98 kwargs = {}
99 99 kwargs['location'] = location
100 100 kwargs['location_keys'] = ['name', 'description']
101 101
102 102 kwargs['title'] = 'Location'
103 103 kwargs['suptitle'] = 'Details'
104 104
105 105 return render(request, 'location.html', kwargs)
106 106
107 107
108 108 @user_passes_test(lambda u:u.is_staff)
109 109 def location_new(request):
110 110
111 111 if request.method == 'GET':
112 112 form = LocationForm()
113 113
114 114 if request.method == 'POST':
115 115 form = LocationForm(request.POST)
116 116
117 117 if form.is_valid():
118 118 form.save()
119 119 return redirect('url_locations')
120 120
121 121 kwargs = {}
122 122 kwargs['form'] = form
123 123 kwargs['title'] = 'Radar System'
124 124 kwargs['suptitle'] = 'New'
125 125 kwargs['button'] = 'Create'
126 126
127 127 return render(request, 'base_edit.html', kwargs)
128 128
129 129
130 130 @user_passes_test(lambda u:u.is_staff)
131 131 def location_edit(request, id_loc):
132 132
133 133 location = get_object_or_404(Location, pk=id_loc)
134 134
135 135 if request.method=='GET':
136 136 form = LocationForm(instance=location)
137 137
138 138 if request.method=='POST':
139 139 form = LocationForm(request.POST, instance=location)
140 140
141 141 if form.is_valid():
142 142 form.save()
143 143 return redirect('url_locations')
144 144
145 145 kwargs = {}
146 146 kwargs['form'] = form
147 147 kwargs['title'] = 'Location'
148 148 kwargs['suptitle'] = 'Edit'
149 149 kwargs['button'] = 'Update'
150 150
151 151 return render(request, 'base_edit.html', kwargs)
152 152
153 153
154 154 @user_passes_test(lambda u:u.is_staff)
155 155 def location_delete(request, id_loc):
156 156
157 157 location = get_object_or_404(Location, pk=id_loc)
158 158
159 159 if request.method=='POST':
160 160
161 161 if request.user.is_staff:
162 162 location.delete()
163 163 return redirect('url_locations')
164 164
165 165 messages.error(request, 'Not enough permission to delete this object')
166 166 return redirect(location.get_absolute_url())
167 167
168 168 kwargs = {
169 169 'title': 'Delete',
170 170 'suptitle': 'Location',
171 171 'object': location,
172 172 'previous': location.get_absolute_url(),
173 173 'delete': True
174 174 }
175 175
176 176 return render(request, 'confirm.html', kwargs)
177 177
178 178
179 179 def devices(request):
180 180
181 181 page = request.GET.get('page')
182 182 order = ('device_type', 'name')
183 183
184 184 kwargs = get_paginator(Device, page, order)
185 185 kwargs['keys'] = ['name', 'ip_address', 'port_address', 'device_type']
186 186 kwargs['title'] = 'Device'
187 187 kwargs['suptitle'] = 'List'
188 188 kwargs['no_sidebar'] = True
189 189
190 190 return render(request, 'base_list.html', kwargs)
191 191
192 192
193 193 def device(request, id_dev):
194 194
195 195 device = get_object_or_404(Device, pk=id_dev)
196 196
197 197 kwargs = {}
198 198 kwargs['device'] = device
199 199 kwargs['device_keys'] = ['device_type', 'name', 'ip_address', 'port_address', 'description']
200 200
201 201 kwargs['title'] = 'Device'
202 202 kwargs['suptitle'] = 'Details'
203 203
204 204 return render(request, 'device.html', kwargs)
205 205
206 206
207 207 @user_passes_test(lambda u:u.is_staff)
208 208 def device_new(request):
209 209
210 210 if request.method == 'GET':
211 211 form = DeviceForm()
212 212
213 213 if request.method == 'POST':
214 214 form = DeviceForm(request.POST)
215 215
216 216 if form.is_valid():
217 217 form.save()
218 218 return redirect('url_devices')
219 219
220 220 kwargs = {}
221 221 kwargs['form'] = form
222 222 kwargs['title'] = 'Device'
223 223 kwargs['suptitle'] = 'New'
224 224 kwargs['button'] = 'Create'
225 225
226 226 return render(request, 'base_edit.html', kwargs)
227 227
228 228
229 229 @user_passes_test(lambda u:u.is_staff)
230 230 def device_edit(request, id_dev):
231 231
232 232 device = get_object_or_404(Device, pk=id_dev)
233 233
234 234 if request.method=='GET':
235 235 form = DeviceForm(instance=device)
236 236
237 237 if request.method=='POST':
238 238 form = DeviceForm(request.POST, instance=device)
239 239
240 240 if form.is_valid():
241 241 form.save()
242 242 return redirect(device.get_absolute_url())
243 243
244 244 kwargs = {}
245 245 kwargs['form'] = form
246 246 kwargs['title'] = 'Device'
247 247 kwargs['suptitle'] = 'Edit'
248 248 kwargs['button'] = 'Update'
249 249
250 250 return render(request, 'base_edit.html', kwargs)
251 251
252 252
253 253 @user_passes_test(lambda u:u.is_staff)
254 254 def device_delete(request, id_dev):
255 255
256 256 device = get_object_or_404(Device, pk=id_dev)
257 257
258 258 if request.method=='POST':
259 259
260 260 if request.user.is_staff:
261 261 device.delete()
262 262 return redirect('url_devices')
263 263
264 264 messages.error(request, 'Not enough permission to delete this object')
265 265 return redirect(device.get_absolute_url())
266 266
267 267 kwargs = {
268 268 'title': 'Delete',
269 269 'suptitle': 'Device',
270 270 'object': device,
271 271 'previous': device.get_absolute_url(),
272 272 'delete': True
273 273 }
274 274
275 275 return render(request, 'confirm.html', kwargs)
276 276
277 277
278 278 @user_passes_test(lambda u:u.is_staff)
279 279 def device_change_ip(request, id_dev):
280 280
281 281 device = get_object_or_404(Device, pk=id_dev)
282 282
283 283 if request.method=='POST':
284 284
285 285 if request.user.is_staff:
286 286 device.change_ip(**request.POST.dict())
287 287 level, message = device.message.split('|')
288 288 messages.add_message(request, level, message)
289 289 else:
290 290 messages.error(request, 'Not enough permission to delete this object')
291 291 return redirect(device.get_absolute_url())
292 292
293 293 kwargs = {
294 294 'title': 'Device',
295 295 'suptitle': 'Change IP',
296 296 'object': device,
297 297 'previous': device.get_absolute_url(),
298 298 'form': ChangeIpForm(initial={'ip_address':device.ip_address}),
299 299 'message' : ' ',
300 300 }
301 301
302 302 return render(request, 'confirm.html', kwargs)
303 303
304 304
305 305 def campaigns(request):
306 306
307 307 page = request.GET.get('page')
308 308 order = ('start_date',)
309 309 filters = request.GET.copy()
310 310
311 311 kwargs = get_paginator(Campaign, page, order, filters)
312 312
313 313 form = FilterForm(initial=request.GET, extra_fields=['range_date', 'tags','template'])
314 314 kwargs['keys'] = ['name', 'start_date', 'end_date']
315 315 kwargs['title'] = 'Campaign'
316 316 kwargs['suptitle'] = 'List'
317 317 kwargs['no_sidebar'] = True
318 318 kwargs['form'] = form
319 319 filters.pop('page', None)
320 320 kwargs['q'] = urlencode(filters)
321 321
322 322 return render(request, 'base_list.html', kwargs)
323 323
324 324
325 325 def campaign(request, id_camp):
326 326
327 327 campaign = get_object_or_404(Campaign, pk=id_camp)
328 328 experiments = Experiment.objects.filter(campaign=campaign)
329 329
330 330 form = CampaignForm(instance=campaign)
331 331
332 332 kwargs = {}
333 333 kwargs['campaign'] = campaign
334 334 kwargs['campaign_keys'] = ['template', 'name', 'start_date', 'end_date', 'tags', 'description']
335 335
336 336 kwargs['experiments'] = experiments
337 337 kwargs['experiment_keys'] = ['name', 'radar_system', 'start_time', 'end_time']
338 338
339 339 kwargs['title'] = 'Campaign'
340 340 kwargs['suptitle'] = 'Details'
341 341
342 342 kwargs['form'] = form
343 343 kwargs['button'] = 'Add Experiment'
344 344
345 345 return render(request, 'campaign.html', kwargs)
346 346
347 347
348 348 @user_passes_test(lambda u:u.is_staff)
349 349 def campaign_new(request):
350 350
351 351 kwargs = {}
352 352
353 353 if request.method == 'GET':
354 354
355 355 if 'template' in request.GET:
356 356 if request.GET['template']=='0':
357 357 form = NewForm(initial={'create_from':2},
358 358 template_choices=Campaign.objects.filter(template=True).values_list('id', 'name'))
359 359 else:
360 360 kwargs['button'] = 'Create'
361 361 kwargs['experiments'] = Configuration.objects.filter(experiment=request.GET['template'])
362 362 kwargs['experiment_keys'] = ['name', 'start_time', 'end_time']
363 363 camp = Campaign.objects.get(pk=request.GET['template'])
364 364 form = CampaignForm(instance=camp,
365 365 initial={'name':'{} [{:%Y/%m/%d}]'.format(camp.name, datetime.now()),
366 366 'template':False})
367 367 elif 'blank' in request.GET:
368 368 kwargs['button'] = 'Create'
369 369 form = CampaignForm()
370 370 else:
371 371 form = NewForm()
372 372
373 373 if request.method == 'POST':
374 374 kwargs['button'] = 'Create'
375 375 post = request.POST.copy()
376 376 experiments = []
377 377
378 378 for id_exp in post.getlist('experiments'):
379 379 exp = Experiment.objects.get(pk=id_exp)
380 380 new_exp = exp.clone(template=False)
381 381 experiments.append(new_exp)
382 382
383 383 post.setlist('experiments', [])
384 384
385 385 form = CampaignForm(post)
386 386
387 387 if form.is_valid():
388 388 campaign = form.save()
389 389 for exp in experiments:
390 390 campaign.experiments.add(exp)
391 391 campaign.save()
392 392 return redirect('url_campaign', id_camp=campaign.id)
393 393
394 394 kwargs['form'] = form
395 395 kwargs['title'] = 'Campaign'
396 396 kwargs['suptitle'] = 'New'
397 397
398 398 return render(request, 'campaign_edit.html', kwargs)
399 399
400 400
401 401 @user_passes_test(lambda u:u.is_staff)
402 402 def campaign_edit(request, id_camp):
403 403
404 404 campaign = get_object_or_404(Campaign, pk=id_camp)
405 405
406 406 if request.method=='GET':
407 407 form = CampaignForm(instance=campaign)
408 408
409 409 if request.method=='POST':
410 410 exps = campaign.experiments.all().values_list('pk', flat=True)
411 411 post = request.POST.copy()
412 412 new_exps = post.getlist('experiments')
413 413 post.setlist('experiments', [])
414 414 form = CampaignForm(post, instance=campaign)
415 415
416 416 if form.is_valid():
417 417 camp = form.save()
418 418 for id_exp in new_exps:
419 419 if int(id_exp) in exps:
420 420 exps.pop(id_exp)
421 421 else:
422 422 exp = Experiment.objects.get(pk=id_exp)
423 423 if exp.template:
424 424 camp.experiments.add(exp.clone(template=False))
425 425 else:
426 426 camp.experiments.add(exp)
427 427
428 428 for id_exp in exps:
429 429 camp.experiments.remove(Experiment.objects.get(pk=id_exp))
430 430
431 431 return redirect('url_campaign', id_camp=id_camp)
432 432
433 433 kwargs = {}
434 434 kwargs['form'] = form
435 435 kwargs['title'] = 'Campaign'
436 436 kwargs['suptitle'] = 'Edit'
437 437 kwargs['button'] = 'Update'
438 438
439 439 return render(request, 'campaign_edit.html', kwargs)
440 440
441 441
442 442 @user_passes_test(lambda u:u.is_staff)
443 443 def campaign_delete(request, id_camp):
444 444
445 445 campaign = get_object_or_404(Campaign, pk=id_camp)
446 446
447 447 if request.method=='POST':
448 448 if request.user.is_staff:
449 449
450 450 for exp in campaign.experiments.all():
451 451 for conf in Configuration.objects.filter(experiment=exp):
452 452 conf.delete()
453 453 exp.delete()
454 454 campaign.delete()
455 455
456 456 return redirect('url_campaigns')
457 457
458 458 messages.error(request, 'Not enough permission to delete this object')
459 459 return redirect(campaign.get_absolute_url())
460 460
461 461 kwargs = {
462 462 'title': 'Delete',
463 463 'suptitle': 'Campaign',
464 464 'object': campaign,
465 465 'previous': campaign.get_absolute_url(),
466 466 'delete': True
467 467 }
468 468
469 469 return render(request, 'confirm.html', kwargs)
470 470
471 471
472 472 @user_passes_test(lambda u:u.is_staff)
473 473 def campaign_export(request, id_camp):
474 474
475 475 campaign = get_object_or_404(Campaign, pk=id_camp)
476 476 content = campaign.parms_to_dict()
477 477 content_type = 'application/json'
478 478 filename = '%s_%s.json' %(campaign.name, campaign.id)
479 479
480 480 response = HttpResponse(content_type=content_type)
481 481 response['Content-Disposition'] = 'attachment; filename="%s"' %filename
482 482 response.write(content)
483 483
484 484 return response
485 485
486 486
487 487 @user_passes_test(lambda u:u.is_staff)
488 488 def campaign_import(request, id_camp):
489 489
490 490 campaign = get_object_or_404(Campaign, pk=id_camp)
491 491
492 492 if request.method == 'GET':
493 493 file_form = UploadFileForm()
494 494
495 495 if request.method == 'POST':
496 496 file_form = UploadFileForm(request.POST, request.FILES)
497 497
498 498 if file_form.is_valid():
499 499
500 500 parms = campaign.import_from_file(request.FILES['file'])
501 501
502 502 if parms:
503 503 parms['name'] = parms['campaign']
504 504
505 505 new_camp = campaign.dict_to_parms(parms, CONF_MODELS)
506 506
507 507 messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name)
508 508
509 509 return redirect(new_camp.get_absolute_url_edit())
510 510
511 511 messages.error(request, "Could not import parameters from file")
512 512
513 513 kwargs = {}
514 514 kwargs['title'] = 'Campaign'
515 515 kwargs['form'] = file_form
516 516 kwargs['suptitle'] = 'Importing file'
517 517 kwargs['button'] = 'Import'
518 518
519 519 return render(request, 'campaign_import.html', kwargs)
520 520
521 521
522 522 def experiments(request):
523 523
524 524 page = request.GET.get('page')
525 525 order = ('location',)
526 526 filters = request.GET.copy()
527 527
528 528 kwargs = get_paginator(Experiment, page, order, filters)
529 529
530 530 form = FilterForm(initial=request.GET, extra_fields=['tags','template'])
531 531
532 532 kwargs['keys'] = ['name', 'radar_system', 'start_time', 'end_time']
533 533 kwargs['title'] = 'Experiment'
534 534 kwargs['suptitle'] = 'List'
535 535 kwargs['no_sidebar'] = True
536 536 kwargs['form'] = form
537 537 filters.pop('page', None)
538 538 kwargs['q'] = urlencode(filters)
539 539
540 540 return render(request, 'base_list.html', kwargs)
541 541
542 542
543 543 def experiment(request, id_exp):
544 544
545 545 experiment = get_object_or_404(Experiment, pk=id_exp)
546 546 #experiment.get_status()
547 547 configurations = Configuration.objects.filter(experiment=experiment, type=0)
548 548
549 549 kwargs = {}
550 550
551 551 kwargs['experiment_keys'] = ['radar_system', 'name', 'start_time', 'end_time']
552 552 kwargs['experiment'] = experiment
553 553
554 554 kwargs['configuration_keys'] = ['name', 'device__ip_address', 'device__port_address', 'device__status']
555 555 kwargs['configurations'] = configurations
556 556
557 557 kwargs['title'] = 'Experiment'
558 558 kwargs['suptitle'] = 'Details'
559 559
560 560 kwargs['button'] = 'Add Configuration'
561 561
562 562 ###### SIDEBAR ######
563 563 kwargs.update(sidebar(experiment=experiment))
564 564
565 565 return render(request, 'experiment.html', kwargs)
566 566
567 567
568 568 @user_passes_test(lambda u:u.is_staff)
569 569 def experiment_new(request, id_camp=None):
570 570
571 571 kwargs = {}
572 572
573 573 if request.method == 'GET':
574 574 if 'template' in request.GET:
575 575 if request.GET['template']=='0':
576 576 form = NewForm(initial={'create_from':2},
577 577 template_choices=Experiment.objects.filter(template=True).values_list('id', 'name'))
578 578 else:
579 579 kwargs['button'] = 'Create'
580 580 kwargs['configurations'] = Configuration.objects.filter(experiment=request.GET['template'])
581 581 kwargs['configuration_keys'] = ['name', 'device__name', 'device__ip_address', 'device__port_address']
582 582 exp=Experiment.objects.get(pk=request.GET['template'])
583 583 form = ExperimentForm(instance=exp,
584 584 initial={'name': '{} [{:%Y/%m/%d}]'.format(exp.name, datetime.now()),
585 585 'template': False})
586 586 elif 'blank' in request.GET:
587 587 kwargs['button'] = 'Create'
588 588 form = ExperimentForm()
589 589 else:
590 590 form = NewForm()
591 591
592 592 if request.method == 'POST':
593 593 form = ExperimentForm(request.POST)
594 594 if form.is_valid():
595 595 experiment = form.save()
596 596
597 597 if 'template' in request.GET:
598 598 configurations = Configuration.objects.filter(experiment=request.GET['template'], type=0)
599 599 for conf in configurations:
600 600 conf.clone(experiment=experiment, template=False)
601 601
602 602 return redirect('url_experiment', id_exp=experiment.id)
603 603
604 604 kwargs['form'] = form
605 605 kwargs['title'] = 'Experiment'
606 606 kwargs['suptitle'] = 'New'
607 607
608 608 return render(request, 'experiment_edit.html', kwargs)
609 609
610 610
611 611 @user_passes_test(lambda u:u.is_staff)
612 612 def experiment_edit(request, id_exp):
613 613
614 614 experiment = get_object_or_404(Experiment, pk=id_exp)
615 615
616 616 if request.method == 'GET':
617 617 form = ExperimentForm(instance=experiment)
618 618
619 619 if request.method=='POST':
620 620 form = ExperimentForm(request.POST, instance=experiment)
621 621
622 622 if form.is_valid():
623 623 experiment = form.save()
624 624 return redirect('url_experiment', id_exp=experiment.id)
625 625
626 626 kwargs = {}
627 627 kwargs['form'] = form
628 628 kwargs['title'] = 'Experiment'
629 629 kwargs['suptitle'] = 'Edit'
630 630 kwargs['button'] = 'Update'
631 631
632 632 return render(request, 'experiment_edit.html', kwargs)
633 633
634 634
635 635 @user_passes_test(lambda u:u.is_staff)
636 636 def experiment_delete(request, id_exp):
637 637
638 638 experiment = get_object_or_404(Experiment, pk=id_exp)
639 639
640 640 if request.method=='POST':
641 641 if request.user.is_staff:
642 642 for conf in Configuration.objects.filter(experiment=experiment):
643 643 conf.delete()
644 644 experiment.delete()
645 645 return redirect('url_experiments')
646 646
647 647 messages.error(request, 'Not enough permission to delete this object')
648 648 return redirect(experiment.get_absolute_url())
649 649
650 650 kwargs = {
651 651 'title': 'Delete',
652 652 'suptitle': 'Experiment',
653 653 'object': experiment,
654 654 'previous': experiment.get_absolute_url(),
655 655 'delete': True
656 656 }
657 657
658 658 return render(request, 'confirm.html', kwargs)
659 659
660 660
661 661 @user_passes_test(lambda u:u.is_staff)
662 662 def experiment_export(request, id_exp):
663 663
664 664 experiment = get_object_or_404(Experiment, pk=id_exp)
665 665 content = experiment.parms_to_dict()
666 666 content_type = 'application/json'
667 667 filename = '%s_%s.json' %(experiment.name, experiment.id)
668 668
669 669 response = HttpResponse(content_type=content_type)
670 670 response['Content-Disposition'] = 'attachment; filename="%s"' %filename
671 671 response.write(content)
672 672
673 673 return response
674 674
675 675
676 676 @user_passes_test(lambda u:u.is_staff)
677 677 def experiment_import(request, id_exp):
678 678
679 679 experiment = get_object_or_404(Experiment, pk=id_exp)
680 680 configurations = Configuration.objects.filter(experiment=experiment)
681 681
682 682 if request.method == 'GET':
683 683 file_form = UploadFileForm()
684 684
685 685 if request.method == 'POST':
686 686 file_form = UploadFileForm(request.POST, request.FILES)
687 687
688 688 if file_form.is_valid():
689 689
690 690 parms = experiment.import_from_file(request.FILES['file'])
691 691
692 692 if parms:
693 693
694 694 new_exp = experiment.dict_to_parms(parms, CONF_MODELS)
695 695
696 696 if new_exp.__class__.__name__=='dict':
697 697 messages.error(request, new_exp['Error'] )
698 698 return redirect(experiment.get_absolute_url_import())
699 699
700 700 messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name)
701 701
702 702 return redirect(new_exp.get_absolute_url_edit())
703 703
704 704 messages.error(request, "Could not import parameters from file")
705 705
706 706 kwargs = {}
707 707 kwargs['title'] = 'Experiment'
708 708 kwargs['form'] = file_form
709 709 kwargs['suptitle'] = 'Importing file'
710 710 kwargs['button'] = 'Import'
711 711
712 712 kwargs.update(sidebar(experiment=experiment))
713 713
714 714 return render(request, 'experiment_import.html', kwargs)
715 715
716 716
717 717 @user_passes_test(lambda u:u.is_staff)
718 718 def experiment_start(request, id_exp):
719 719
720 720 exp = get_object_or_404(Experiment, pk=id_exp)
721 721
722 722 confs = Configuration.objects.filter(experiment=exp, type=0)
723 723 if not confs:
724 724 messages.error(request, 'Experiment not running. No Device Configurations detected.')
725 725 return redirect(exp.get_absolute_url())
726 726
727 727 for conf in confs:
728 728 conf.status_device()
729 729 if conf.device.status != 2:
730 730 messages.error(request, 'Experiment not running. Configuration {} state: '.format(conf) + DEV_STATES[conf.device.status][1])
731 731 return redirect(exp.get_absolute_url())
732 732
733 733 exp.get_status()
734 734
735 735 if exp.status == 2:
736 736 messages.warning(request, 'Experiment {} already running'.format(exp))
737 737 else:
738 738 task = task_start.delay(exp.pk)
739 739 exp.status = task.wait()
740
740 741 if exp.status==0:
741 742 messages.error(request, 'Experiment {} not start'.format(exp))
742 743 if exp.status==2:
743 744 messages.success(request, 'Experiment {} started'.format(exp))
745 task_status.delay(exp.pk) #background get_status function
744 746 exp.save()
745 747
746 748 return redirect(exp.get_absolute_url())
747 749
748 750
749 751 @user_passes_test(lambda u:u.is_staff)
750 752 def experiment_stop(request, id_exp):
751 753
752 754 exp = get_object_or_404(Experiment, pk=id_exp)
753 755 confs = Configuration.objects.filter(experiment=exp, type=0)
754 756 if not confs:
755 757 messages.error(request, 'No Device Configurations detected.')
756 758 return redirect(exp.get_absolute_url())
757 759
758 760 exp.get_status()
759 761
760 762 if exp.status == 2:
761 763 task = task_stop.delay(exp.pk)
762 764 exp.status = task.wait()
763 765 messages.warning(request, 'Experiment {} stopped'.format(exp))
764 766 exp.save()
765 767 else:
766 768 messages.error(request, 'Experiment {} not running'.format(exp))
767 769
768 770 return redirect(exp.get_absolute_url())
769 771
770 772
771 773 @user_passes_test(lambda u:u.is_staff)
772 774 def experiment_mix(request, id_exp):
773 775
774 776 experiment = get_object_or_404(Experiment, pk=id_exp)
775 777 rc_confs = [conf for conf in RCConfiguration.objects.filter(experiment=id_exp,
776 778 mix=False)]
777 779
778 780 if len(rc_confs)<2:
779 781 messages.warning(request, 'You need at least two RC Configurations to make a mix')
780 782 return redirect(experiment.get_absolute_url())
781 783
782 784 mix_confs = RCConfiguration.objects.filter(experiment=id_exp, mix=True)
783 785
784 786 if mix_confs:
785 787 mix = mix_confs[0]
786 788 else:
787 789 mix = RCConfiguration(experiment=experiment,
788 790 device=rc_confs[0].device,
789 791 ipp=rc_confs[0].ipp,
790 792 clock_in=rc_confs[0].clock_in,
791 793 clock_divider=rc_confs[0].clock_divider,
792 794 mix=True,
793 795 parameters='')
794 796 mix.save()
795 797
796 798 line_type = RCLineType.objects.get(name='mix')
797 799 for i in range(len(rc_confs[0].get_lines())):
798 800 line = RCLine(rc_configuration=mix, line_type=line_type, channel=i)
799 801 line.save()
800 802
801 803 initial = {'name': mix.name,
802 804 'result': parse_mix_result(mix.parameters),
803 805 'delay': 0,
804 806 'mask': [0,1,2,3,4,5,6,7]
805 807 }
806 808
807 809 if request.method=='GET':
808 810 form = RCMixConfigurationForm(confs=rc_confs, initial=initial)
809 811
810 812 if request.method=='POST':
811 813 result = mix.parameters
812 814
813 815 if '{}|'.format(request.POST['experiment']) in result:
814 816 messages.error(request, 'Configuration already added')
815 817 else:
816 818 if 'operation' in request.POST:
817 819 operation = MIX_OPERATIONS[request.POST['operation']]
818 820 else:
819 821 operation = ' '
820 822
821 823 mode = MIX_MODES[request.POST['mode']]
822 824
823 825 if result:
824 826 result = '{}-{}|{}|{}|{}|{}'.format(mix.parameters,
825 827 request.POST['experiment'],
826 828 mode,
827 829 operation,
828 830 float(request.POST['delay']),
829 831 parse_mask(request.POST.getlist('mask'))
830 832 )
831 833 else:
832 834 result = '{}|{}|{}|{}|{}'.format(request.POST['experiment'],
833 835 mode,
834 836 operation,
835 837 float(request.POST['delay']),
836 838 parse_mask(request.POST.getlist('mask'))
837 839 )
838 840
839 841 mix.parameters = result
840 842 mix.name = request.POST['name']
841 843 mix.save()
842 844 mix.update_pulses()
843 845
844 846 initial['result'] = parse_mix_result(result)
845 847 initial['name'] = mix.name
846 848
847 849 form = RCMixConfigurationForm(initial=initial, confs=rc_confs)
848 850
849 851
850 852 kwargs = {
851 853 'title': 'Experiment',
852 854 'suptitle': 'Mix Configurations',
853 855 'form' : form,
854 856 'extra_button': 'Delete',
855 857 'button': 'Add',
856 858 'cancel': 'Back',
857 859 'previous': experiment.get_absolute_url(),
858 860 'id_exp':id_exp,
859 861
860 862 }
861 863
862 864 return render(request, 'experiment_mix.html', kwargs)
863 865
864 866
865 867 @user_passes_test(lambda u:u.is_staff)
866 868 def experiment_mix_delete(request, id_exp):
867 869
868 870 conf = RCConfiguration.objects.get(experiment=id_exp, mix=True)
869 871 values = conf.parameters.split('-')
870 872 conf.parameters = '-'.join(values[:-1])
871 873 conf.save()
872 874
873 875 return redirect('url_mix_experiment', id_exp=id_exp)
874 876
875 877
876 878 def experiment_summary(request, id_exp):
877 879
878 880 experiment = get_object_or_404(Experiment, pk=id_exp)
879 881 configurations = Configuration.objects.filter(experiment=experiment, type=0)
880 882
881 883 kwargs = {}
882 884
883 885 kwargs['experiment_keys'] = ['radar_system', 'name', 'start_time', 'end_time']
884 886 kwargs['experiment'] = experiment
885 887
886 888 kwargs['configurations'] = []
887 889
888 890 kwargs['title'] = 'Experiment Summary'
889 891 kwargs['suptitle'] = 'Details'
890 892
891 893 kwargs['button'] = 'Verify Parameters'
892 894
893 895 jars_conf = False
894 896 rc_conf = False
895 897
896 898 for configuration in configurations:
897 899
898 900 #--------------------- RC ----------------------:
899 901 if configuration.device.device_type.name == 'rc':
900 902 if configuration.mix:
901 903 continue
902 904 rc_conf = True
903 905 ipp = configuration.ipp
904 906 lines = configuration.get_lines(line_type__name='tx')
905 907 configuration.tx_lines = []
906 908
907 909 for tx_line in lines:
908 910 line = {'name':tx_line.get_name()}
909 911 tx_params = json.loads(tx_line.params)
910 912 line['width'] = tx_params['pulse_width']
911 913 if line['width'] in (0, '0'):
912 914 continue
913 915 delays = tx_params['delays']
914 916
915 917 if delays not in ('', '0'):
916 918 n = len(delays.split(','))
917 919 line['taus'] = '{} Taus: {}'.format(n, delays)
918 920 else:
919 921 line['taus'] = '-'
920 922
921 923 for code_line in configuration.get_lines(line_type__name='codes'):
922 924 code_params = json.loads(code_line.params)
923 925 if tx_line.pk==int(code_params['TX_ref']):
924 926 line['codes'] = '{}:{}'.format(RCLineCode.objects.get(pk=code_params['code']),
925 927 '-'.join(code_params['codes']))
926 928
927 929 for windows_line in configuration.get_lines(line_type__name='windows'):
928 930 win_params = json.loads(windows_line.params)
929 931 if tx_line.pk==int(win_params['TX_ref']):
930 932 windows = ''
931 933 for i, params in enumerate(win_params['params']):
932 934 windows += 'W{}: Ho={first_height} km DH={resolution} km NSA={number_of_samples}<br>'.format(i, **params)
933 935 line['windows'] = mark_safe(windows)
934 936
935 937 configuration.tx_lines.append(line)
936 938
937 939 #-------------------- JARS -----------------------:
938 940 if configuration.device.device_type.name == 'jars':
939 941 jars_conf = True
940 942 kwargs['exp_type'] = EXPERIMENT_TYPE[configuration.exp_type][1]
941 943 channels_number = configuration.channels_number
942 944 exp_type = configuration.exp_type
943 945 fftpoints = configuration.fftpoints
944 946 filter_parms = configuration.filter_parms
945 947 filter_parms = ast.literal_eval(filter_parms)
946 948 spectral_number = configuration.spectral_number
947 949
948 950
949 951 kwargs['configurations'].append(configuration)
950 952
951 953
952 954 #------ RC & JARS ------:
953 955 ipp = 937.5 #
954 956 nsa = 200#
955 957 dh = 1.5 #
956 958 channels_number = 5 #
957 959
958 960 if rc_conf and jars_conf:
959 961 if exp_type == 0: #Short
960 962 bytes = 2
961 963 b = nsa*2*bytes*channels_number
962 964 else: #Float
963 965 bytes = 4
964 966 channels = channels_number + spectral_number
965 967 b = nsa*2*bytes*fftpoints*channels
966 968
967 969 ipps = (ipp*pow(10,-6))/0.15
968 970 GB = 1048576.0*1024.0
969 971 Hour = 3600
970 972 rate = b/ipps
971 973 rate = rate *(1/GB)*(Hour)
972 974 kwargs['rate'] = str(rate)+" GB/h"
973 975 else:
974 976 kwargs['rate'] = ''
975 977
976 978 ###### SIDEBAR ######
977 979 kwargs.update(sidebar(experiment=experiment))
978 980
979 981 return render(request, 'experiment_summary.html', kwargs)
980 982
981 983
982 984 @user_passes_test(lambda u:u.is_staff)
983 985 def experiment_verify(request, id_exp):
984 986
985 987 experiment = get_object_or_404(Experiment, pk=id_exp)
986 988 experiment_data = json.loads(experiment.parms_to_dict())
987 989 configurations = Configuration.objects.filter(experiment=experiment, type=0)
988 990
989 991 kwargs = {}
990 992
991 993 kwargs['experiment_keys'] = ['template', 'radar_system', 'name', 'start_time', 'end_time']
992 994 kwargs['experiment'] = experiment
993 995
994 996 kwargs['configuration_keys'] = ['name', 'device__ip_address', 'device__port_address', 'device__status']
995 997 kwargs['configurations'] = configurations
996 998 kwargs['experiment_data'] = experiment_data
997 999
998 1000 kwargs['title'] = 'Verify Experiment'
999 1001 kwargs['suptitle'] = 'Parameters'
1000 1002
1001 1003 kwargs['button'] = 'Update'
1002 1004
1003 1005 jars_conf = False
1004 1006 rc_conf = False
1005 1007 dds_conf = False
1006 1008
1007 1009 for configuration in configurations:
1008 1010 #-------------------- JARS -----------------------:
1009 1011 if configuration.device.device_type.name == 'jars':
1010 1012 jars_conf = True
1011 1013 jars = configuration
1012 1014 kwargs['jars_conf'] = jars_conf
1013 1015 filter_parms = configuration.filter_parms
1014 1016 filter_parms = ast.literal_eval(filter_parms)
1015 1017 kwargs['filter_parms'] = filter_parms
1016 1018 #--Sampling Frequency
1017 1019 clock = filter_parms['clock']
1018 1020 filter_2 = filter_parms['filter_2']
1019 1021 filter_5 = filter_parms['filter_5']
1020 1022 filter_fir = filter_parms['filter_fir']
1021 1023 samp_freq_jars = clock/filter_2/filter_5/filter_fir
1022 1024
1023 1025 kwargs['samp_freq_jars'] = samp_freq_jars
1024 1026 kwargs['jars'] = configuration
1025 1027
1026 1028 #--------------------- RC ----------------------:
1027 1029 if configuration.device.device_type.name == 'rc' and not configuration.mix:
1028 1030 rc_conf = True
1029 1031 rc = configuration
1030 1032
1031 1033 rc_parms = configuration.parms_to_dict()
1032 1034
1033 1035 win_lines = rc.get_lines(line_type__name='windows')
1034 1036 if win_lines:
1035 1037 dh = json.loads(win_lines[0].params)['params'][0]['resolution']
1036 1038 #--Sampling Frequency
1037 1039 samp_freq_rc = 0.15/dh
1038 1040 kwargs['samp_freq_rc'] = samp_freq_rc
1039 1041
1040 1042 kwargs['rc_conf'] = rc_conf
1041 1043 kwargs['rc'] = configuration
1042 1044
1043 1045 #-------------------- DDS ----------------------:
1044 1046 if configuration.device.device_type.name == 'dds':
1045 1047 dds_conf = True
1046 1048 dds = configuration
1047 1049 dds_parms = configuration.parms_to_dict()
1048 1050
1049 1051 kwargs['dds_conf'] = dds_conf
1050 1052 kwargs['dds'] = configuration
1051 1053
1052 1054
1053 1055 #------------Validation------------:
1054 1056 #Clock
1055 1057 if dds_conf and rc_conf and jars_conf:
1056 1058 if float(filter_parms['clock']) != float(rc_parms['clock_in']) and float(rc_parms['clock_in']) != float(dds_parms['clock']):
1057 1059 messages.warning(request, "Devices don't have the same clock.")
1058 1060 elif rc_conf and jars_conf:
1059 1061 if float(filter_parms['clock']) != float(rc_parms['clock_in']):
1060 1062 messages.warning(request, "Devices don't have the same clock.")
1061 1063 elif rc_conf and dds_conf:
1062 1064 if float(rc_parms['clock_in']) != float(dds_parms['clock']):
1063 1065 messages.warning(request, "Devices don't have the same clock.")
1064 1066 if float(samp_freq_rc) != float(dds_parms['frequencyA']):
1065 1067 messages.warning(request, "Devices don't have the same Frequency A.")
1066 1068
1067 1069
1068 1070 #------------POST METHOD------------:
1069 1071 if request.method == 'POST':
1070 1072 if request.POST['suggest_clock']:
1071 1073 try:
1072 1074 suggest_clock = float(request.POST['suggest_clock'])
1073 1075 except:
1074 1076 messages.warning(request, "Invalid value in CLOCK IN.")
1075 1077 return redirect('url_verify_experiment', id_exp=experiment.id)
1076 1078 else:
1077 1079 suggest_clock = ""
1078 1080 if suggest_clock:
1079 1081 if rc_conf:
1080 1082 rc.clock_in = suggest_clock
1081 1083 rc.save()
1082 1084 if jars_conf:
1083 1085 filter_parms = jars.filter_parms
1084 1086 filter_parms = ast.literal_eval(filter_parms)
1085 1087 filter_parms['clock'] = suggest_clock
1086 1088 jars.filter_parms = json.dumps(filter_parms)
1087 1089 jars.save()
1088 1090 kwargs['filter_parms'] = filter_parms
1089 1091 if dds_conf:
1090 1092 dds.clock = suggest_clock
1091 1093 dds.save()
1092 1094
1093 1095 if request.POST['suggest_frequencyA']:
1094 1096 try:
1095 1097 suggest_frequencyA = float(request.POST['suggest_frequencyA'])
1096 1098 except:
1097 1099 messages.warning(request, "Invalid value in FREQUENCY A.")
1098 1100 return redirect('url_verify_experiment', id_exp=experiment.id)
1099 1101 else:
1100 1102 suggest_frequencyA = ""
1101 1103 if suggest_frequencyA:
1102 1104 if jars_conf:
1103 1105 filter_parms = jars.filter_parms
1104 1106 filter_parms = ast.literal_eval(filter_parms)
1105 1107 filter_parms['fch'] = suggest_frequencyA
1106 1108 jars.filter_parms = json.dumps(filter_parms)
1107 1109 jars.save()
1108 1110 kwargs['filter_parms'] = filter_parms
1109 1111 if dds_conf:
1110 1112 dds.frequencyA_Mhz = request.POST['suggest_frequencyA']
1111 1113 dds.save()
1112 1114
1113 1115 ###### SIDEBAR ######
1114 1116 kwargs.update(sidebar(experiment=experiment))
1115 1117
1116 1118
1117 1119
1118 1120
1119 1121
1120 1122 return render(request, 'experiment_verify.html', kwargs)
1121 1123
1122 1124
1123 1125 #@user_passes_test(lambda u:u.is_staff)
1124 1126 def parse_mix_result(s):
1125 1127
1126 1128 values = s.split('-')
1127 1129 html = 'EXP MOD OPE DELAY MASK\r\n'
1128 1130
1129 1131 if not values or values[0] in ('', ' '):
1130 1132 return mark_safe(html)
1131 1133
1132 1134 for i, value in enumerate(values):
1133 1135 if not value:
1134 1136 continue
1135 1137 pk, mode, operation, delay, mask = value.split('|')
1136 1138 conf = RCConfiguration.objects.get(pk=pk)
1137 1139 if i==0:
1138 1140 html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format(
1139 1141 conf.name,
1140 1142 mode,
1141 1143 ' ',
1142 1144 delay,
1143 1145 mask)
1144 1146 else:
1145 1147 html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format(
1146 1148 conf.name,
1147 1149 mode,
1148 1150 operation,
1149 1151 delay,
1150 1152 mask)
1151 1153
1152 1154 return mark_safe(html)
1153 1155
1154 1156 def parse_mask(l):
1155 1157
1156 1158 values = []
1157 1159
1158 1160 for x in range(8):
1159 1161 if '{}'.format(x) in l:
1160 1162 values.append(1)
1161 1163 else:
1162 1164 values.append(0)
1163 1165
1164 1166 values.reverse()
1165 1167
1166 1168 return int(''.join([str(x) for x in values]), 2)
1167 1169
1168 1170
1169 1171 def dev_confs(request):
1170 1172
1171 1173
1172 1174 page = request.GET.get('page')
1173 1175 order = ('type', 'device__device_type', 'experiment')
1174 1176 filters = request.GET.copy()
1175 1177
1176 1178 kwargs = get_paginator(Configuration, page, order, filters)
1177 1179
1178 1180 form = FilterForm(initial=request.GET, extra_fields=['tags','template'])
1179 1181 kwargs['keys'] = ['name', 'experiment', 'type', 'programmed_date']
1180 1182 kwargs['title'] = 'Configuration'
1181 1183 kwargs['suptitle'] = 'List'
1182 1184 kwargs['no_sidebar'] = True
1183 1185 kwargs['form'] = form
1184 1186 filters.pop('page', None)
1185 1187 kwargs['q'] = urlencode(filters)
1186 1188
1187 1189 return render(request, 'base_list.html', kwargs)
1188 1190
1189 1191
1190 1192 def dev_conf(request, id_conf):
1191 1193
1192 1194 conf = get_object_or_404(Configuration, pk=id_conf)
1193 1195
1194 1196 return redirect(conf.get_absolute_url())
1195 1197
1196 1198
1197 1199 @user_passes_test(lambda u:u.is_staff)
1198 1200 def dev_conf_new(request, id_exp=0, id_dev=0):
1199 1201
1200 1202 initial = {}
1201 1203 kwargs = {}
1202 1204
1203 1205 if id_exp!=0:
1204 1206 initial['experiment'] = id_exp
1205 1207
1206 1208 if id_dev!=0:
1207 1209 initial['device'] = id_dev
1208 1210
1209 1211 if request.method == 'GET':
1210 1212
1211 1213 if id_dev:
1212 1214 kwargs['button'] = 'Create'
1213 1215 device = Device.objects.get(pk=id_dev)
1214 1216 DevConfForm = CONF_FORMS[device.device_type.name]
1215 1217 initial['name'] = request.GET['name']
1216 1218 form = DevConfForm(initial=initial)
1217 1219 else:
1218 1220 if 'template' in request.GET:
1219 1221 if request.GET['template']=='0':
1220 1222 choices = [(conf.pk, '{}'.format(conf)) for conf in Configuration.objects.filter(template=True)]
1221 1223 form = NewForm(initial={'create_from':2},
1222 1224 template_choices=choices)
1223 1225 else:
1224 1226 kwargs['button'] = 'Create'
1225 1227 conf = Configuration.objects.get(pk=request.GET['template'])
1226 1228 id_dev = conf.device.pk
1227 1229 DevConfForm = CONF_FORMS[conf.device.device_type.name]
1228 1230 form = DevConfForm(instance=conf,
1229 1231 initial={'name': '{} [{:%Y/%m/%d}]'.format(conf.name, datetime.now()),
1230 1232 'template': False,
1231 1233 'experiment':id_exp})
1232 1234 elif 'blank' in request.GET:
1233 1235 kwargs['button'] = 'Create'
1234 1236 form = ConfigurationForm(initial=initial)
1235 1237 else:
1236 1238 form = NewForm()
1237 1239
1238 1240 if request.method == 'POST':
1239 1241
1240 1242 device = Device.objects.get(pk=request.POST['device'])
1241 1243 DevConfForm = CONF_FORMS[device.device_type.name]
1242 1244
1243 1245 form = DevConfForm(request.POST)
1244 1246 kwargs['button'] = 'Create'
1245 1247 if form.is_valid():
1246 1248 conf = form.save()
1247 1249
1248 1250 if 'template' in request.GET and conf.device.device_type.name=='rc':
1249 1251 lines = RCLine.objects.filter(rc_configuration=request.GET['template'])
1250 1252 for line in lines:
1251 1253 line.clone(rc_configuration=conf)
1252 1254
1253 1255 if conf.device.device_type.name=='jars':
1254 1256 conf.add_parms_to_filter()
1255 1257
1256 1258 return redirect('url_dev_conf', id_conf=conf.pk)
1257 1259
1258 1260 kwargs['id_exp'] = id_exp
1259 1261 kwargs['form'] = form
1260 1262 kwargs['title'] = 'Configuration'
1261 1263 kwargs['suptitle'] = 'New'
1262 1264
1263 1265
1264 1266 if id_dev != 0:
1265 1267 device = Device.objects.get(pk=id_dev)
1266 1268 kwargs['device'] = device.device_type.name
1267 1269
1268 1270 return render(request, 'dev_conf_edit.html', kwargs)
1269 1271
1270 1272
1271 1273 @user_passes_test(lambda u:u.is_staff)
1272 1274 def dev_conf_edit(request, id_conf):
1273 1275
1274 1276 conf = get_object_or_404(Configuration, pk=id_conf)
1275 1277
1276 1278 DevConfForm = CONF_FORMS[conf.device.device_type.name]
1277 1279
1278 1280 if request.method=='GET':
1279 1281 form = DevConfForm(instance=conf)
1280 1282
1281 1283 if request.method=='POST':
1282 1284 form = DevConfForm(request.POST, instance=conf)
1283 1285
1284 1286 if form.is_valid():
1285 1287 form.save()
1286 1288 return redirect('url_dev_conf', id_conf=id_conf)
1287 1289
1288 1290 kwargs = {}
1289 1291 kwargs['form'] = form
1290 1292 kwargs['title'] = 'Device Configuration'
1291 1293 kwargs['suptitle'] = 'Edit'
1292 1294 kwargs['button'] = 'Update'
1293 1295
1294 1296 ###### SIDEBAR ######
1295 1297 kwargs.update(sidebar(conf=conf))
1296 1298
1297 1299 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
1298 1300
1299 1301
1300 1302 @user_passes_test(lambda u:u.is_staff)
1301 1303 def dev_conf_start(request, id_conf):
1302 1304
1303 1305 conf = get_object_or_404(Configuration, pk=id_conf)
1304 1306
1305 1307 if conf.start_device():
1306 1308 messages.success(request, conf.message)
1307 1309 else:
1308 1310 messages.error(request, conf.message)
1309 1311
1310 1312 #conf.status_device()
1311 1313
1312 1314 return redirect(conf.get_absolute_url())
1313 1315
1314 1316
1315 1317 @user_passes_test(lambda u:u.is_staff)
1316 1318 def dev_conf_stop(request, id_conf):
1317 1319
1318 1320 conf = get_object_or_404(Configuration, pk=id_conf)
1319 1321
1320 1322 if conf.stop_device():
1321 1323 messages.success(request, conf.message)
1322 1324 else:
1323 1325 messages.error(request, conf.message)
1324 1326
1325 1327 #conf.status_device()
1326 1328
1327 1329 return redirect(conf.get_absolute_url())
1328 1330
1329 1331
1330 1332 def dev_conf_status(request, id_conf):
1331 1333
1332 1334 conf = get_object_or_404(Configuration, pk=id_conf)
1333 1335
1334 1336 if conf.status_device():
1335 1337 messages.success(request, conf.message)
1336 1338 else:
1337 1339 messages.error(request, conf.message)
1338 1340
1339 1341 return redirect(conf.get_absolute_url())
1340 1342
1341 1343
1342 1344 @user_passes_test(lambda u:u.is_staff)
1343 1345 def dev_conf_write(request, id_conf):
1344 1346
1345 1347 conf = get_object_or_404(Configuration, pk=id_conf)
1346 1348
1347 1349 if conf.write_device():
1348 1350 messages.success(request, conf.message)
1349 1351 conf.clone(type=1, template=False)
1350 1352 else:
1351 1353 messages.error(request, conf.message)
1352 1354
1353 1355 return redirect(conf.get_absolute_url())
1354 1356
1355 1357
1356 1358 @user_passes_test(lambda u:u.is_staff)
1357 1359 def dev_conf_read(request, id_conf):
1358 1360
1359 1361 conf = get_object_or_404(Configuration, pk=id_conf)
1360 1362
1361 1363 DevConfForm = CONF_FORMS[conf.device.device_type.name]
1362 1364
1363 1365 if request.method=='GET':
1364 1366
1365 1367 parms = conf.read_device()
1366 1368 #conf.status_device()
1367 1369
1368 1370 if not parms:
1369 1371 messages.error(request, conf.message)
1370 1372 return redirect(conf.get_absolute_url())
1371 1373
1372 1374 form = DevConfForm(initial=parms, instance=conf)
1373 1375
1374 1376 if request.method=='POST':
1375 1377 form = DevConfForm(request.POST, instance=conf)
1376 1378
1377 1379 if form.is_valid():
1378 1380 form.save()
1379 1381 return redirect(conf.get_absolute_url())
1380 1382
1381 1383 messages.error(request, "Parameters could not be saved")
1382 1384
1383 1385 kwargs = {}
1384 1386 kwargs['id_dev'] = conf.id
1385 1387 kwargs['form'] = form
1386 1388 kwargs['title'] = 'Device Configuration'
1387 1389 kwargs['suptitle'] = 'Parameters read from device'
1388 1390 kwargs['button'] = 'Save'
1389 1391
1390 1392 ###### SIDEBAR ######
1391 1393 kwargs.update(sidebar(conf=conf))
1392 1394
1393 1395 return render(request, '%s_conf_edit.html' %conf.device.device_type.name, kwargs)
1394 1396
1395 1397
1396 1398 @user_passes_test(lambda u:u.is_staff)
1397 1399 def dev_conf_import(request, id_conf):
1398 1400
1399 1401 conf = get_object_or_404(Configuration, pk=id_conf)
1400 1402 DevConfForm = CONF_FORMS[conf.device.device_type.name]
1401 1403
1402 1404 if request.method == 'GET':
1403 1405 file_form = UploadFileForm()
1404 1406
1405 1407 if request.method == 'POST':
1406 1408 file_form = UploadFileForm(request.POST, request.FILES)
1407 1409
1408 1410 if file_form.is_valid():
1409 1411
1410 1412 parms = conf.import_from_file(request.FILES['file'])
1411 1413
1412 1414 if parms:
1413 1415 messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name)
1414 1416 form = DevConfForm(initial=parms, instance=conf)
1415 1417
1416 1418 kwargs = {}
1417 1419 kwargs['id_dev'] = conf.id
1418 1420 kwargs['form'] = form
1419 1421 kwargs['title'] = 'Device Configuration'
1420 1422 kwargs['suptitle'] = 'Parameters imported'
1421 1423 kwargs['button'] = 'Save'
1422 1424 kwargs['action'] = conf.get_absolute_url_edit()
1423 1425 kwargs['previous'] = conf.get_absolute_url()
1424 1426
1425 1427 ###### SIDEBAR ######
1426 1428 kwargs.update(sidebar(conf=conf))
1427 1429
1428 1430 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
1429 1431
1430 1432 messages.error(request, "Could not import parameters from file")
1431 1433
1432 1434 kwargs = {}
1433 1435 kwargs['id_dev'] = conf.id
1434 1436 kwargs['title'] = 'Device Configuration'
1435 1437 kwargs['form'] = file_form
1436 1438 kwargs['suptitle'] = 'Importing file'
1437 1439 kwargs['button'] = 'Import'
1438 1440
1439 1441 kwargs.update(sidebar(conf=conf))
1440 1442
1441 1443 return render(request, 'dev_conf_import.html', kwargs)
1442 1444
1443 1445
1444 1446 @user_passes_test(lambda u:u.is_staff)
1445 1447 def dev_conf_export(request, id_conf):
1446 1448
1447 1449 conf = get_object_or_404(Configuration, pk=id_conf)
1448 1450
1449 1451 if request.method == 'GET':
1450 1452 file_form = DownloadFileForm(conf.device.device_type.name)
1451 1453
1452 1454 if request.method == 'POST':
1453 1455 file_form = DownloadFileForm(conf.device.device_type.name, request.POST)
1454 1456
1455 1457 if file_form.is_valid():
1456 1458 fields = conf.export_to_file(format = file_form.cleaned_data['format'])
1457 1459
1458 1460 response = HttpResponse(content_type=fields['content_type'])
1459 1461 response['Content-Disposition'] = 'attachment; filename="%s"' %fields['filename']
1460 1462 response.write(fields['content'])
1461 1463
1462 1464 return response
1463 1465
1464 1466 messages.error(request, "Could not export parameters")
1465 1467
1466 1468 kwargs = {}
1467 1469 kwargs['id_dev'] = conf.id
1468 1470 kwargs['title'] = 'Device Configuration'
1469 1471 kwargs['form'] = file_form
1470 1472 kwargs['suptitle'] = 'Exporting file'
1471 1473 kwargs['button'] = 'Export'
1472 1474
1473 1475 return render(request, 'dev_conf_export.html', kwargs)
1474 1476
1475 1477
1476 1478 @user_passes_test(lambda u:u.is_staff)
1477 1479 def dev_conf_delete(request, id_conf):
1478 1480
1479 1481 conf = get_object_or_404(Configuration, pk=id_conf)
1480 1482
1481 1483 if request.method=='POST':
1482 1484 if request.user.is_staff:
1483 1485 conf.delete()
1484 1486 return redirect('url_dev_confs')
1485 1487
1486 1488 messages.error(request, 'Not enough permission to delete this object')
1487 1489 return redirect(conf.get_absolute_url())
1488 1490
1489 1491 kwargs = {
1490 1492 'title': 'Delete',
1491 1493 'suptitle': 'Experiment',
1492 1494 'object': conf,
1493 1495 'previous': conf.get_absolute_url(),
1494 1496 'delete': True
1495 1497 }
1496 1498
1497 1499 return render(request, 'confirm.html', kwargs)
1498 1500
1499 1501
1500 1502 def sidebar(**kwargs):
1501 1503
1502 1504 side_data = {}
1503 1505
1504 1506 conf = kwargs.get('conf', None)
1505 1507 experiment = kwargs.get('experiment', None)
1506 1508
1507 1509 if not experiment:
1508 1510 experiment = conf.experiment
1509 1511
1510 1512 if experiment:
1511 1513 side_data['experiment'] = experiment
1512 1514 campaign = experiment.campaign_set.all()
1513 1515 if campaign:
1514 1516 side_data['campaign'] = campaign[0]
1515 1517 experiments = campaign[0].experiments.all()
1516 1518 else:
1517 1519 experiments = [experiment]
1518 1520 configurations = experiment.configuration_set.filter(type=0)
1519 1521 side_data['side_experiments'] = experiments
1520 1522 side_data['side_configurations'] = configurations
1521 1523
1522 1524 return side_data
1523 1525
1524 1526 def get_paginator(model, page, order, filters={}, n=10):
1525 1527
1526 1528 kwargs = {}
1527 1529 query = Q()
1528 1530 if isinstance(filters, QueryDict):
1529 1531 filters = filters.dict()
1530 1532 [filters.pop(key) for key in filters.keys() if filters[key] in ('', ' ')]
1531 1533 filters.pop('page', None)
1532 1534
1533 1535 if 'template' in filters:
1534 1536 filters['template'] = True
1535 1537 if 'start_date' in filters:
1536 1538 filters['start_date__gte'] = filters.pop('start_date')
1537 1539 if 'end_date' in filters:
1538 1540 filters['start_date__lte'] = filters.pop('end_date')
1539 1541 if 'tags' in filters:
1540 1542 tags = filters.pop('tags')
1541 1543 fields = [f.name for f in model._meta.get_fields()]
1542 1544
1543 1545 if 'tags' in fields:
1544 1546 query = query | Q(tags__icontains=tags)
1545 1547 if 'name' in fields:
1546 1548 query = query | Q(name__icontains=tags)
1547 1549 if 'location' in fields:
1548 1550 query = query | Q(location__name__icontains=tags)
1549 1551 if 'device' in fields:
1550 1552 query = query | Q(device__device_type__name__icontains=tags)
1551 1553
1552 1554 object_list = model.objects.filter(query, **filters).order_by(*order)
1553 1555 paginator = Paginator(object_list, n)
1554 1556
1555 1557 try:
1556 1558 objects = paginator.page(page)
1557 1559 except PageNotAnInteger:
1558 1560 objects = paginator.page(1)
1559 1561 except EmptyPage:
1560 1562 objects = paginator.page(paginator.num_pages)
1561 1563
1562 1564 kwargs['objects'] = objects
1563 1565 kwargs['offset'] = (int(page)-1)*n if page else 0
1564 1566
1565 1567 return kwargs
1566 1568
1567 1569 def operation(request, id_camp=None):
1568 1570
1569 1571 kwargs = {}
1570 1572 kwargs['title'] = 'Radars Operation'
1571 1573 kwargs['no_sidebar'] = True
1572 1574 campaigns = Campaign.objects.filter(start_date__lte=datetime.now(),
1573 1575 end_date__gte=datetime.now()).order_by('-start_date')
1574 1576
1575 1577
1576 1578 if id_camp:
1577 1579 campaign = get_object_or_404(Campaign, pk = id_camp)
1578 1580 form = OperationForm(initial={'campaign': campaign.id}, campaigns=campaigns)
1579 1581 kwargs['campaign'] = campaign
1580 1582 else:
1581 1583 form = OperationForm(campaigns=campaigns)
1582 1584 kwargs['form'] = form
1583 1585 return render(request, 'operation.html', kwargs)
1584 1586
1585 1587 #---Experiment
1586 1588 keys = ['id', 'name', 'start_time', 'end_time', 'status']
1587 1589 kwargs['experiment_keys'] = keys[1:]
1588 1590 kwargs['experiments'] = experiments
1589 1591 #---Radar
1590 1592 kwargs['locations'] = campaign.get_experiments_by_radar()
1591 1593 kwargs['form'] = form
1592 1594
1593 1595 return render(request, 'operation.html', kwargs)
1594 1596
1595 1597
1596 1598 @login_required
1597 1599 def radar_start(request, id_camp, id_radar):
1598 1600
1599 1601 campaign = get_object_or_404(Campaign, pk = id_camp)
1600 1602 experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments']
1601 1603 now = datetime.utcnow()
1602 1604
1603 1605 for exp in experiments:
1604 1606 date = datetime.combine(datetime.now().date(), exp.start_time)
1605 1607
1606 1608 if exp.status == 2:
1607 1609 messages.warning(request, 'Experiment {} already running'.format(exp))
1608 1610 continue
1609 1611
1610 1612 if exp.status == 3:
1611 1613 messages.warning(request, 'Experiment {} already programmed'.format(exp))
1612 1614 continue
1613 1615
1614 1616 if date>campaign.end_date or date<campaign.start_date:
1615 1617 messages.warning(request, 'Experiment {} out of date'.format(exp))
1616 1618 continue
1617 1619
1618 1620 if now>=date:
1619 1621 task = task_start.delay(exp.pk)
1620 1622 exp.status = task.wait()
1621 1623 if exp.status==0:
1622 1624 messages.error(request, 'Experiment {} not start'.format(exp))
1623 1625 if exp.status==2:
1624 1626 messages.success(request, 'Experiment {} started'.format(exp))
1625 1627 else:
1626 1628 task = task_start.apply_async((exp.pk,), eta=date)
1627 1629 exp.status = 3
1628 1630 messages.success(request, 'Experiment {} programmed to start at {}'.format(exp, date))
1629 1631
1630 1632 exp.save()
1631 1633
1632 1634 return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
1633 1635
1634 1636
1635 1637 @login_required
1636 1638 def radar_stop(request, id_camp, id_radar):
1637 1639
1638 1640 campaign = get_object_or_404(Campaign, pk = id_camp)
1639 1641 experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments']
1640 1642
1641 1643 for exp in experiments:
1642 1644
1643 1645 if exp.status == 2:
1644 1646 task = task_stop.delay(exp.pk)
1645 1647 exp.status = task.wait()
1646 1648 messages.warning(request, 'Experiment {} stopped'.format(exp))
1647 1649 exp.save()
1648 1650 else:
1649 1651 messages.error(request, 'Experiment {} not running'.format(exp))
1650 1652
1651 1653 return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
1652 1654
1653 1655
1654 1656 @login_required
1655 1657 def radar_refresh(request, id_camp, id_radar):
1656 1658
1657 1659 campaign = get_object_or_404(Campaign, pk = id_camp)
1658 1660 experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments']
1659 1661
1660 1662 for exp in experiments:
1661 1663 exp.get_status()
1662 1664
1663 1665 return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
General Comments 0
You need to be logged in to leave comments. Login now