##// END OF EJS Templates
radarsys
RSS
Add profile model to user
Juan C. Espinoza -
r319:f3ab02e8e413
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,10 +1,11
1 1 from django.contrib import admin
2 from .models import Device, DeviceType, Experiment, Campaign, Location, RunningExperiment
2 from .models import Device, DeviceType, Experiment, Campaign, Location, RunningExperiment, Profile
3 3
4 4 # Register your models here.
5 5 admin.site.register(Campaign)
6 6 admin.site.register(Experiment)
7 7 admin.site.register(Device)
8 8 admin.site.register(DeviceType)
9 9 admin.site.register(Location)
10 admin.site.register(RunningExperiment) No newline at end of file
10 admin.site.register(RunningExperiment)
11 admin.site.register(Profile) No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,794 +1,809
1 1
2 2 import os
3 3 import json
4 4 import requests
5 5 import time
6 6 from datetime import datetime
7 7
8 8 try:
9 9 from polymorphic.models import PolymorphicModel
10 10 except:
11 11 from polymorphic import PolymorphicModel
12 12
13 13 from django.template.base import kwarg_re
14 14 from django.db import models
15 15 from django.core.urlresolvers import reverse
16 16 from django.core.validators import MinValueValidator, MaxValueValidator
17 17 from django.shortcuts import get_object_or_404
18 18 from django.contrib.auth.models import User
19 from django.db.models.signals import post_save
20 from django.dispatch import receiver
19 21
20 22 from apps.main.utils import Params
21 23 from apps.rc.utils import RCFile
22 24 from apps.jars.utils import RacpFile
23 25 from devices.dds import api as dds_api
24 26 from devices.dds import data as dds_data
25 27
26 28
27 29 DEV_PORTS = {
28 30 'rc' : 2000,
29 31 'dds' : 2000,
30 32 'jars' : 2000,
31 33 'usrp' : 2000,
32 34 'cgs' : 8080,
33 35 'abs' : 8080
34 36 }
35 37
36 38 RADAR_STATES = (
37 39 (0, 'No connected'),
38 40 (1, 'Connected'),
39 41 (2, 'Configured'),
40 42 (3, 'Running'),
41 43 (4, 'Scheduled'),
42 44 )
43 45
44 46 EXPERIMENT_TYPE = (
45 47 (0, 'RAW_DATA'),
46 48 (1, 'PDATA'),
47 49 )
48 50
49 51 DECODE_TYPE = (
50 52 (0, 'None'),
51 53 (1, 'TimeDomain'),
52 54 (2, 'FreqDomain'),
53 55 (3, 'InvFreqDomain'),
54 56 )
55 57
56 58 DEV_STATES = (
57 59 (0, 'No connected'),
58 60 (1, 'Connected'),
59 61 (2, 'Configured'),
60 62 (3, 'Running'),
61 63 (4, 'Unknown'),
62 64 )
63 65
64 66 DEV_TYPES = (
65 67 ('', 'Select a device type'),
66 68 ('rc', 'Radar Controller'),
67 69 ('dds', 'Direct Digital Synthesizer'),
68 70 ('jars', 'Jicamarca Radar Acquisition System'),
69 71 ('usrp', 'Universal Software Radio Peripheral'),
70 72 ('cgs', 'Clock Generator System'),
71 73 ('abs', 'Automatic Beam Switching'),
72 74 )
73 75
74 76 EXP_STATES = (
75 77 (0,'Error'), #RED
76 78 (1,'Configured'), #BLUE
77 79 (2,'Running'), #GREEN
78 80 (3,'Scheduled'), #YELLOW
79 81 (4,'Not Configured'), #WHITE
80 82 )
81 83
82 84 CONF_TYPES = (
83 85 (0, 'Active'),
84 86 (1, 'Historical'),
85 87 )
86 88
89 class Profile(models.Model):
90 user = models.OneToOneField(User, on_delete=models.CASCADE)
91 theme = models.CharField(max_length=30, default='yeti')
92
93 @receiver(post_save, sender=User)
94 def create_user_profile(sender, instance, created, **kwargs):
95 if created:
96 Profile.objects.create(user=instance)
97
98 @receiver(post_save, sender=User)
99 def save_user_profile(sender, instance, **kwargs):
100 instance.profile.save()
101
102
87 103 class Location(models.Model):
88 104
89 105 name = models.CharField(max_length = 30)
90 106 description = models.TextField(blank=True, null=True)
91 107
92 108 class Meta:
93 109 db_table = 'db_location'
94 110
95 111 def __str__(self):
96 112 return u'%s' % self.name
97 113
98 114 def get_absolute_url(self):
99 115 return reverse('url_location', args=[str(self.id)])
100 116
101 117
102 118 class DeviceType(models.Model):
103 119
104 120 name = models.CharField(max_length = 10, choices = DEV_TYPES, default = 'rc')
105 121 sequence = models.PositiveSmallIntegerField(default=1000)
106 122 description = models.TextField(blank=True, null=True)
107 123
108 124 class Meta:
109 125 db_table = 'db_device_types'
110 126
111 127 def __str__(self):
112 128 return u'%s' % self.get_name_display()
113 129
114 130 class Device(models.Model):
115 131
116 132 device_type = models.ForeignKey(DeviceType, on_delete=models.CASCADE)
117 133 location = models.ForeignKey(Location, on_delete=models.CASCADE)
118 134 ip_address = models.GenericIPAddressField(protocol='IPv4', default='0.0.0.0')
119 135 port_address = models.PositiveSmallIntegerField(default=2000)
120 136 description = models.TextField(blank=True, null=True)
121 137 status = models.PositiveSmallIntegerField(default=0, choices=DEV_STATES)
122 138
123 139 class Meta:
124 140 db_table = 'db_devices'
125 141
126 142 def __str__(self):
127 143 ret = u'{} [{}]'.format(self.device_type.name.upper(), self.location.name)
128 144
129 145 return ret
130 146
131 147 @property
132 148 def name(self):
133 149 return str(self)
134 150
135 151 def get_status(self):
136 152 return self.status
137 153
138 154 @property
139 155 def status_color(self):
140 156 color = 'muted'
141 157 if self.status == 0:
142 158 color = "danger"
143 159 elif self.status == 1:
144 160 color = "warning"
145 161 elif self.status == 2:
146 162 color = "info"
147 163 elif self.status == 3:
148 164 color = "success"
149 165
150 166 return color
151 167
152 168 def url(self, path=None):
153 169
154 170 if path:
155 171 return 'http://{}:{}/{}/'.format(self.ip_address, self.port_address, path)
156 172 else:
157 173 return 'http://{}:{}/'.format(self.ip_address, self.port_address)
158 174
159 175 def get_absolute_url(self):
160 176 return reverse('url_device', args=[str(self.id)])
161 177
162 178 def get_absolute_url_edit(self):
163 179 return reverse('url_edit_device', args=[str(self.id)])
164 180
165 181 def get_absolute_url_delete(self):
166 182 return reverse('url_delete_device', args=[str(self.id)])
167 183
168 184 def change_ip(self, ip_address, mask, gateway, dns, **kwargs):
169 185
170 186 if self.device_type.name=='dds':
171 187 try:
172 188 answer = dds_api.change_ip(ip = self.ip_address,
173 189 port = self.port_address,
174 190 new_ip = ip_address,
175 191 mask = mask,
176 192 gateway = gateway)
177 193 if answer[0]=='1':
178 194 self.message = '25|DDS - {}'.format(answer)
179 195 self.ip_address = ip_address
180 196 self.save()
181 197 else:
182 198 self.message = '30|DDS - {}'.format(answer)
183 199 return False
184 200 except Exception as e:
185 201 self.message = '40|{}'.format(str(e))
186 202 return False
187 203
188 204 elif self.device_type.name=='rc':
189 205 headers = {'content-type': "application/json",
190 206 'cache-control': "no-cache"}
191 207
192 208 ip = [int(x) for x in ip_address.split('.')]
193 209 dns = [int(x) for x in dns.split('.')]
194 210 gateway = [int(x) for x in gateway.split('.')]
195 211 subnet = [int(x) for x in mask.split('.')]
196 212
197 213 payload = {
198 214 "ip": ip,
199 215 "dns": dns,
200 216 "gateway": gateway,
201 217 "subnet": subnet
202 218 }
203 219
204 220 req = requests.post(self.url('changeip'), data=json.dumps(payload), headers=headers)
205 221 try:
206 222 answer = req.json()
207 223 if answer['changeip']=='ok':
208 224 self.message = '25|IP succesfully changed'
209 225 self.ip_address = ip_address
210 226 self.save()
211 227 else:
212 228 self.message = '30|An error ocuur when changing IP'
213 229 except Exception as e:
214 230 self.message = '40|{}'.format(str(e))
215 231 else:
216 232 self.message = 'Not implemented'
217 233 return False
218 234
219 235 return True
220 236
221 237
222 238 class Campaign(models.Model):
223 239
224 240 template = models.BooleanField(default=False)
225 241 name = models.CharField(max_length=60, unique=True)
226 242 start_date = models.DateTimeField(blank=True, null=True)
227 243 end_date = models.DateTimeField(blank=True, null=True)
228 244 tags = models.CharField(max_length=40, blank=True, null=True)
229 245 description = models.TextField(blank=True, null=True)
230 246 experiments = models.ManyToManyField('Experiment', blank=True)
231 247 author = models.ForeignKey(User, null=True, blank=True)
232 248
233 249 class Meta:
234 250 db_table = 'db_campaigns'
235 251 ordering = ('name',)
236 252
237 253 def __str__(self):
238 254 if self.template:
239 255 return u'{} (template)'.format(self.name)
240 256 else:
241 257 return u'{}'.format(self.name)
242 258
243 259 def jsonify(self):
244 260
245 261 data = {}
246 262
247 263 ignored = ('template')
248 264
249 265 for field in self._meta.fields:
250 266 if field.name in ignored:
251 267 continue
252 268 data[field.name] = field.value_from_object(self)
253 269
254 270 data['start_date'] = data['start_date'].strftime('%Y-%m-%d')
255 271 data['end_date'] = data['end_date'].strftime('%Y-%m-%d')
256 272
257 273 return data
258 274
259 275 def parms_to_dict(self):
260 276
261 277 params = Params({})
262 278 params.add(self.jsonify(), 'campaigns')
263 279
264 280 for exp in Experiment.objects.filter(campaign = self):
265 281 params.add(exp.jsonify(), 'experiments')
266 282 configurations = Configuration.objects.filter(experiment=exp, type=0)
267 283
268 284 for conf in configurations:
269 285 params.add(conf.jsonify(), 'configurations')
270 286 if conf.device.device_type.name=='rc':
271 287 for line in conf.get_lines():
272 288 params.add(line.jsonify(), 'lines')
273 289
274 290 return params.data
275 291
276 292 def dict_to_parms(self, parms, CONF_MODELS):
277 293
278 294 experiments = Experiment.objects.filter(campaign = self)
279 295
280 296 if experiments:
281 297 for experiment in experiments:
282 298 experiment.delete()
283 299
284 300 for id_exp in parms['experiments']['allIds']:
285 301 exp_parms = parms['experiments']['byId'][id_exp]
286 302 dum = (datetime.now() - datetime(1970, 1, 1)).total_seconds()
287 303 exp = Experiment(name='{}'.format(dum))
288 304 exp.save()
289 305 exp.dict_to_parms(parms, CONF_MODELS, id_exp=id_exp)
290 306 self.experiments.add(exp)
291 307
292 308 camp_parms = parms['campaigns']['byId'][parms['campaigns']['allIds'][0]]
293 309
294 310 self.name = '{}-{}'.format(camp_parms['name'], datetime.now().strftime('%y%m%d'))
295 311 self.start_date = camp_parms['start_date']
296 312 self.end_date = camp_parms['end_date']
297 313 self.tags = camp_parms['tags']
298 314 self.save()
299 315
300 316 return self
301 317
302 318 def get_experiments_by_radar(self, radar=None):
303 319
304 320 ret = []
305 321 if radar:
306 322 locations = Location.objects.filter(pk=radar)
307 323 else:
308 324 locations = set([e.location for e in self.experiments.all()])
309 325
310 326 for loc in locations:
311 327 dum = {}
312 328 dum['name'] = loc.name
313 329 dum['id'] = loc.pk
314 330 dum['experiments'] = [e for e in self.experiments.all() if e.location==loc]
315 331 ret.append(dum)
316 332
317 333 return ret
318 334
319 335 def get_absolute_url(self):
320 336 return reverse('url_campaign', args=[str(self.id)])
321 337
322 338 def get_absolute_url_edit(self):
323 339 return reverse('url_edit_campaign', args=[str(self.id)])
324 340
325 341 def get_absolute_url_delete(self):
326 342 return reverse('url_delete_campaign', args=[str(self.id)])
327 343
328 344 def get_absolute_url_export(self):
329 345 return reverse('url_export_campaign', args=[str(self.id)])
330 346
331 347 def get_absolute_url_import(self):
332 348 return reverse('url_import_campaign', args=[str(self.id)])
333 349
334 350
335 351 class RunningExperiment(models.Model):
336 352 radar = models.OneToOneField('Location', on_delete=models.CASCADE)
337 353 running_experiment = models.ManyToManyField('Experiment', blank = True)
338 354 status = models.PositiveSmallIntegerField(default=0, choices=RADAR_STATES)
339 355
340 356
341 357 class Experiment(models.Model):
342 358
343 359 template = models.BooleanField(default=False)
344 360 name = models.CharField(max_length=40, default='', unique=True)
345 361 location = models.ForeignKey('Location', null=True, blank=True, on_delete=models.CASCADE)
346 362 freq = models.FloatField(verbose_name='Operating Freq. (MHz)', validators=[MinValueValidator(1), MaxValueValidator(10000)], default=49.9200)
347 363 start_time = models.TimeField(default='00:00:00')
348 364 end_time = models.TimeField(default='23:59:59')
349 365 task = models.CharField(max_length=36, default='', blank=True, null=True)
350 366 status = models.PositiveSmallIntegerField(default=4, choices=EXP_STATES)
351 367 author = models.ForeignKey(User, null=True, blank=True)
352 368 hash = models.CharField(default='', max_length=64, null=True, blank=True)
353 369
354 370 class Meta:
355 371 db_table = 'db_experiments'
356 372 ordering = ('template', 'name')
357 373
358 374 def __str__(self):
359 375 if self.template:
360 return u'%s (template)' % (self.name[:8])
376 return u'%s (template)' % (self.name)
361 377 else:
362 return u'%s' % (self.name[:10])
378 return u'%s' % (self.name)
363 379
364 380 def jsonify(self):
365 381
366 382 data = {}
367 383
368 384 ignored = ('template')
369 385
370 386 for field in self._meta.fields:
371 387 if field.name in ignored:
372 388 continue
373 389 data[field.name] = field.value_from_object(self)
374 390
375 391 data['start_time'] = data['start_time'].strftime('%H:%M:%S')
376 392 data['end_time'] = data['end_time'].strftime('%H:%M:%S')
377 393 data['location'] = self.location.name
378 394 data['configurations'] = ['{}'.format(conf.pk) for
379 395 conf in Configuration.objects.filter(experiment=self, type=0)]
380 396
381 397 return data
382 398
383 399 @property
384 400 def radar_system(self):
385 401 return self.location
386 402
387 403 def clone(self, **kwargs):
388 404
389 405 confs = Configuration.objects.filter(experiment=self, type=0)
390 406 self.pk = None
391 407 self.name = '{}_{:%y%m%d}'.format(self.name, datetime.now())
392 408 for attr, value in kwargs.items():
393 409 setattr(self, attr, value)
394 410
395 411 self.save()
396 412
397 413 for conf in confs:
398 414 conf.clone(experiment=self, template=False)
399 415
400 416 return self
401 417
402 418 def start(self):
403 419 '''
404 420 Configure and start experiments's devices
405 421 ABS-CGS-DDS-RC-JARS
406 422 '''
407 423
408 424 result = 2
409 425 confs = []
410 426 allconfs = Configuration.objects.filter(experiment=self, type = 0).order_by('-device__device_type__sequence')
411 427 rc_mix = [conf for conf in allconfs if conf.device.device_type.name=='rc' and conf.mix]
412 428 if rc_mix:
413 429 for conf in allconfs:
414 430 if conf.device.device_type.name == 'rc' and not conf.mix:
415 431 continue
416 432 confs.append(conf)
417 433 else:
418 434 confs = allconfs
419 435 #Only Configured Devices.
420 436 for conf in confs:
421 437 if conf.device.status in (0, 4):
422 438 result = 0
423 439 return result
424 440 for conf in confs:
425 441 conf.stop_device()
426 442 conf.write_device()
427 443 conf.start_device()
428 444 time.sleep(1)
429 445
430 446 return result
431 447
432 448
433 449 def stop(self):
434 450 '''
435 451 Stop experiments's devices
436 452 DDS-JARS-RC-CGS-ABS
437 453 '''
438 454
439 455 result = 1
440 456
441 457 confs = Configuration.objects.filter(experiment=self, type = 0).order_by('device__device_type__sequence')
442 458 confs=confs.exclude(device__device_type__name='cgs')
443 459 for conf in confs:
444 460 if conf.device.status in (0, 4):
445 461 result = 0
446 462 continue
447 463 conf.stop_device()
448 464
449 465 return result
450 466
451 467
452 468 def get_status(self):
453 469
454 470 if self.status == 3:
455 471 return
456 472
457 473 confs = Configuration.objects.filter(experiment=self, type=0)
458 474
459 475 for conf in confs:
460 476 conf.status_device()
461 477
462 478 total = confs.aggregate(models.Sum('device__status'))['device__status__sum']
463 479
464 480 if total==2*confs.count():
465 481 status = 1
466 482 elif total == 3*confs.count():
467 483 status = 2
468 484 else:
469 485 status = 0
470 486
471 487 self.status = status
472 488 self.save()
473 489
474 490 def status_color(self):
475 491 color = 'muted'
476 492 if self.status == 0:
477 493 color = "danger"
478 494 elif self.status == 1:
479 495 color = "info"
480 496 elif self.status == 2:
481 497 color = "success"
482 498 elif self.status == 3:
483 499 color = "warning"
484 500
485 501 return color
486 502
487 503 def parms_to_dict(self):
488 504
489 505 params = Params({})
490 506 params.add(self.jsonify(), 'experiments')
491 507
492 508 configurations = Configuration.objects.filter(experiment=self, type=0)
493 509
494 510 for conf in configurations:
495 511 params.add(conf.jsonify(), 'configurations')
496 512 if conf.device.device_type.name=='rc':
497 513 for line in conf.get_lines():
498 514 params.add(line.jsonify(), 'lines')
499 515
500 516 return params.data
501 517
502 518 def dict_to_parms(self, parms, CONF_MODELS, id_exp=None):
503 519
504 520 configurations = Configuration.objects.filter(experiment=self)
505 521
506 522 if id_exp is not None:
507 523 exp_parms = parms['experiments']['byId'][id_exp]
508 524 else:
509 525 exp_parms = parms['experiments']['byId'][parms['experiments']['allIds'][0]]
510 526
511 527 if configurations:
512 528 for configuration in configurations:
513 529 configuration.delete()
514 530
515 531 for id_conf in exp_parms['configurations']:
516 532 conf_parms = parms['configurations']['byId'][id_conf]
517 533 device = Device.objects.filter(device_type__name=conf_parms['device_type'])[0]
518 534 model = CONF_MODELS[conf_parms['device_type']]
519 535 conf = model(
520 536 experiment = self,
521 537 device = device,
522 538 )
523 539 conf.dict_to_parms(parms, id=id_conf)
524 540
525 541
526 542 location, created = Location.objects.get_or_create(name=exp_parms['location'])
527 543 self.name = '{}-{}'.format(exp_parms['name'], datetime.now().strftime('%y%m%d'))
528 544 self.location = location
529 545 self.start_time = exp_parms['start_time']
530 546 self.end_time = exp_parms['end_time']
531 547 self.save()
532 548
533 549 return self
534 550
535 551 def get_absolute_url(self):
536 552 return reverse('url_experiment', args=[str(self.id)])
537 553
538 554 def get_absolute_url_edit(self):
539 555 return reverse('url_edit_experiment', args=[str(self.id)])
540 556
541 557 def get_absolute_url_delete(self):
542 558 return reverse('url_delete_experiment', args=[str(self.id)])
543 559
544 560 def get_absolute_url_import(self):
545 561 return reverse('url_import_experiment', args=[str(self.id)])
546 562
547 563 def get_absolute_url_export(self):
548 564 return reverse('url_export_experiment', args=[str(self.id)])
549 565
550 566 def get_absolute_url_start(self):
551 567 return reverse('url_start_experiment', args=[str(self.id)])
552 568
553 569 def get_absolute_url_stop(self):
554 570 return reverse('url_stop_experiment', args=[str(self.id)])
555 571
556 572
557 573 class Configuration(PolymorphicModel):
558 574
559 575 template = models.BooleanField(default=False)
560 576 # name = models.CharField(verbose_name="Configuration Name", max_length=40, default='')
561 577 label = models.CharField(verbose_name="Label", max_length=40, default='', blank=True, null=True)
562 578 experiment = models.ForeignKey('Experiment', verbose_name='Experiment', null=True, blank=True, on_delete=models.CASCADE)
563 579 device = models.ForeignKey('Device', verbose_name='Device', null=True, on_delete=models.CASCADE)
564 580 type = models.PositiveSmallIntegerField(default=0, choices=CONF_TYPES)
565 581 created_date = models.DateTimeField(auto_now_add=True)
566 582 programmed_date = models.DateTimeField(auto_now=True)
567 583 parameters = models.TextField(default='{}')
568 584 author = models.ForeignKey(User, null=True, blank=True)
569 585 hash = models.CharField(default='', max_length=64, null=True, blank=True)
570 586 message = ""
571 587
572 588 class Meta:
573 589 db_table = 'db_configurations'
574 590 ordering = ('device__device_type__name',)
575 591
576 592 def __str__(self):
577 593
578 594 ret = u'{} '.format(self.device.device_type.name.upper())
579 595
580 596 if 'mix' in [f.name for f in self._meta.get_fields()]:
581 597 if self.mix:
582 598 ret = '{} MIX '.format(self.device.device_type.name.upper())
583 599
584 600 if 'label' in [f.name for f in self._meta.get_fields()]:
585 ret += '{}'.format(self.label[:8])
601 ret += '{}'.format(self.label)
586 602
587 #ret += '[ {} ]'.format(self.device.location.name)
588 603 if self.template:
589 604 ret += ' (template)'
590 605
591 606 return ret
592 607
593 608 @property
594 609 def name(self):
595 610
596 611 return str(self)
597 612
598 613 def jsonify(self):
599 614
600 615 data = {}
601 616
602 617 ignored = ('type', 'polymorphic_ctype', 'configuration_ptr',
603 618 'created_date', 'programmed_date', 'template', 'device',
604 619 'experiment')
605 620
606 621 for field in self._meta.fields:
607 622 if field.name in ignored:
608 623 continue
609 624 data[field.name] = field.value_from_object(self)
610 625
611 626 data['device_type'] = self.device.device_type.name
612 627
613 628 if self.device.device_type.name == 'rc':
614 629 data['lines'] = ['{}'.format(line.pk) for line in self.get_lines()]
615 630 data['delays'] = self.get_delays()
616 631 data['pulses'] = self.get_pulses()
617 632
618 633 elif self.device.device_type.name == 'jars':
619 634 data['decode_type'] = DECODE_TYPE[self.decode_data][1]
620 635
621 636 elif self.device.device_type.name == 'dds':
622 637 data['frequencyA_Mhz'] = float(data['frequencyA_Mhz'])
623 638 data['frequencyB_Mhz'] = float(data['frequencyB_Mhz'])
624 639 data['phaseA'] = dds_data.phase_to_binary(data['phaseA_degrees'])
625 640 data['phaseB'] = dds_data.phase_to_binary(data['phaseB_degrees'])
626 641
627 642 return data
628 643
629 644 def clone(self, **kwargs):
630 645
631 646 self.pk = None
632 647 self.id = None
633 648 for attr, value in kwargs.items():
634 649 setattr(self, attr, value)
635 650
636 651 self.save()
637 652
638 653 return self
639 654
640 655 def parms_to_dict(self):
641 656
642 657 params = Params({})
643 658 params.add(self.jsonify(), 'configurations')
644 659
645 660 if self.device.device_type.name=='rc':
646 661 for line in self.get_lines():
647 662 params.add(line.jsonify(), 'lines')
648 663
649 664 return params.data
650 665
651 666 def parms_to_text(self):
652 667
653 668 raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
654 669
655 670
656 671 def parms_to_binary(self):
657 672
658 673 raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
659 674
660 675
661 676 def dict_to_parms(self, parameters, id=None):
662 677
663 678 params = Params(parameters)
664 679
665 680 if id:
666 681 data = params.get_conf(id_conf=id)
667 682 else:
668 683 data = params.get_conf(dtype=self.device.device_type.name)
669 684
670 685 if data['device_type']=='rc':
671 686 self.clean_lines()
672 687 lines = data.pop('lines', None)
673 688 for line_id in lines:
674 689 pass
675 690
676 691 for key, value in data.items():
677 692 if key not in ('id', 'device_type'):
678 693 setattr(self, key, value)
679 694
680 695 self.save()
681 696
682 697
683 698 def export_to_file(self, format="json"):
684 699
685 700 content_type = ''
686 701
687 702 if format == 'racp':
688 703 content_type = 'text/plain'
689 704 filename = '%s_%s.%s' %(self.device.device_type.name, self.name, 'racp')
690 705 content = self.parms_to_text(file_format = 'racp')
691 706
692 707 if format == 'text':
693 708 content_type = 'text/plain'
694 709 filename = '%s_%s.%s' %(self.device.device_type.name, self.name, self.device.device_type.name)
695 710 content = self.parms_to_text()
696 711
697 712 if format == 'binary':
698 713 content_type = 'application/octet-stream'
699 714 filename = '%s_%s.bin' %(self.device.device_type.name, self.name)
700 715 content = self.parms_to_binary()
701 716
702 717 if not content_type:
703 718 content_type = 'application/json'
704 719 filename = '%s_%s.json' %(self.device.device_type.name, self.name)
705 720 content = json.dumps(self.parms_to_dict(), indent=2)
706 721
707 722 fields = {'content_type':content_type,
708 723 'filename':filename,
709 724 'content':content
710 725 }
711 726
712 727 return fields
713 728
714 729 def import_from_file(self, fp):
715 730
716 731 parms = {}
717 732
718 733 path, ext = os.path.splitext(fp.name)
719 734
720 735 if ext == '.json':
721 736 parms = json.load(fp)
722 737
723 738 if ext == '.dds':
724 739 lines = fp.readlines()
725 740 parms = dds_data.text_to_dict(lines)
726 741
727 742 if ext == '.racp':
728 743 if self.device.device_type.name == 'jars':
729 744 parms = RacpFile(fp).to_dict()
730 745 parms['filter_parms'] = json.loads(self.filter_parms)
731 746 return parms
732 747 parms = RCFile(fp).to_dict()
733 748
734 749 return parms
735 750
736 751 def status_device(self):
737 752
738 753 self.message = 'Function not implemented'
739 754 return False
740 755
741 756
742 757 def stop_device(self):
743 758
744 759 self.message = 'Function not implemented'
745 760 return False
746 761
747 762
748 763 def start_device(self):
749 764
750 765 self.message = 'Function not implemented'
751 766 return False
752 767
753 768
754 769 def write_device(self, parms):
755 770
756 771 self.message = 'Function not implemented'
757 772 return False
758 773
759 774
760 775 def read_device(self):
761 776
762 777 self.message = 'Function not implemented'
763 778 return False
764 779
765 780
766 781 def get_absolute_url(self):
767 782 return reverse('url_%s_conf' % self.device.device_type.name, args=[str(self.id)])
768 783
769 784 def get_absolute_url_edit(self):
770 785 return reverse('url_edit_%s_conf' % self.device.device_type.name, args=[str(self.id)])
771 786
772 787 def get_absolute_url_delete(self):
773 788 return reverse('url_delete_dev_conf', args=[str(self.id)])
774 789
775 790 def get_absolute_url_import(self):
776 791 return reverse('url_import_dev_conf', args=[str(self.id)])
777 792
778 793 def get_absolute_url_export(self):
779 794 return reverse('url_export_dev_conf', args=[str(self.id)])
780 795
781 796 def get_absolute_url_write(self):
782 797 return reverse('url_write_dev_conf', args=[str(self.id)])
783 798
784 799 def get_absolute_url_read(self):
785 800 return reverse('url_read_dev_conf', args=[str(self.id)])
786 801
787 802 def get_absolute_url_start(self):
788 803 return reverse('url_start_dev_conf', args=[str(self.id)])
789 804
790 805 def get_absolute_url_stop(self):
791 806 return reverse('url_stop_dev_conf', args=[str(self.id)])
792 807
793 808 def get_absolute_url_status(self):
794 809 return reverse('url_status_dev_conf', args=[str(self.id)])
General Comments 0
You need to be logged in to leave comments. Login now