@@ -1,9 +1,10 | |||||
1 | from django.contrib import admin |
|
1 | from django.contrib import admin | |
2 | from .models import Device, DeviceType, Experiment, Campaign, Location |
|
2 | from .models import Device, DeviceType, Experiment, Campaign, Location#, RunningExperiment | |
3 |
|
3 | |||
4 | # Register your models here. |
|
4 | # Register your models here. | |
5 | admin.site.register(Campaign) |
|
5 | admin.site.register(Campaign) | |
6 | admin.site.register(Experiment) |
|
6 | admin.site.register(Experiment) | |
7 | admin.site.register(Device) |
|
7 | admin.site.register(Device) | |
8 | admin.site.register(DeviceType) |
|
8 | admin.site.register(DeviceType) | |
9 | admin.site.register(Location) |
|
9 | admin.site.register(Location) | |
|
10 | #admin.site.register(RunningExperiment) No newline at end of file |
@@ -1,295 +1,308 | |||||
1 | from django.db import models |
|
1 | from django.db import models | |
2 | from polymorphic import PolymorphicModel |
|
2 | from polymorphic import PolymorphicModel | |
3 |
|
3 | |||
4 | from django.core.urlresolvers import reverse |
|
4 | from django.core.urlresolvers import reverse | |
5 |
|
5 | |||
6 | CONF_STATES = ( |
|
6 | CONF_STATES = ( | |
7 | (0, 'Disconnected'), |
|
7 | (0, 'Disconnected'), | |
8 | (1, 'Connected'), |
|
8 | (1, 'Connected'), | |
9 |
( |
|
9 | (2, 'Running'), | |
|
10 | ) | |||
|
11 | ||||
|
12 | EXP_STATES = ( | |||
|
13 | (0,'Error'), #RED | |||
|
14 | (1,'Configurated'), #BLUE | |||
|
15 | (2,'Running'), #GREEN | |||
|
16 | (3,'Waiting'), #YELLOW | |||
|
17 | (4,'Nothing'), #WHITE | |||
10 | ) |
|
18 | ) | |
11 |
|
19 | |||
12 | CONF_TYPES = ( |
|
20 | CONF_TYPES = ( | |
13 | (0, 'Active'), |
|
21 | (0, 'Active'), | |
14 | (1, 'Historical'), |
|
22 | (1, 'Historical'), | |
15 | ) |
|
23 | ) | |
16 |
|
24 | |||
17 | DEV_STATES = ( |
|
25 | DEV_STATES = ( | |
18 | (0, 'No connected'), |
|
26 | (0, 'No connected'), | |
19 | (1, 'Connected'), |
|
27 | (1, 'Connected'), | |
20 | (2, 'Configured'), |
|
28 | (2, 'Configured'), | |
21 | (3, 'Running'), |
|
29 | (3, 'Running'), | |
22 | ) |
|
30 | ) | |
23 |
|
31 | |||
24 | DEV_TYPES = ( |
|
32 | DEV_TYPES = ( | |
25 | ('', 'Select a device type'), |
|
33 | ('', 'Select a device type'), | |
26 | ('rc', 'Radar Controller'), |
|
34 | ('rc', 'Radar Controller'), | |
27 | ('dds', 'Direct Digital Synthesizer'), |
|
35 | ('dds', 'Direct Digital Synthesizer'), | |
28 | ('jars', 'Jicamarca Radar Acquisition System'), |
|
36 | ('jars', 'Jicamarca Radar Acquisition System'), | |
29 | ('usrp', 'Universal Software Radio Peripheral'), |
|
37 | ('usrp', 'Universal Software Radio Peripheral'), | |
30 | ('cgs', 'Clock Generator System'), |
|
38 | ('cgs', 'Clock Generator System'), | |
31 | ('abs', 'Automatic Beam Switching'), |
|
39 | ('abs', 'Automatic Beam Switching'), | |
32 | ) |
|
40 | ) | |
33 |
|
41 | |||
34 | DEV_PORTS = { |
|
42 | DEV_PORTS = { | |
35 | 'rc' : 2000, |
|
43 | 'rc' : 2000, | |
36 | 'dds' : 2000, |
|
44 | 'dds' : 2000, | |
37 | 'jars' : 2000, |
|
45 | 'jars' : 2000, | |
38 | 'usrp' : 2000, |
|
46 | 'usrp' : 2000, | |
39 | 'cgs' : 8080, |
|
47 | 'cgs' : 8080, | |
40 | 'abs' : 8080 |
|
48 | 'abs' : 8080 | |
41 | } |
|
49 | } | |
42 |
|
50 | |||
43 | RADAR_STATES = ( |
|
51 | RADAR_STATES = ( | |
44 | (0, 'No connected'), |
|
52 | (0, 'No connected'), | |
45 | (1, 'Connnected'), |
|
53 | (1, 'Connnected'), | |
46 | (2, 'Configured'), |
|
54 | (2, 'Configured'), | |
47 | (3, 'Running'), |
|
55 | (3, 'Running'), | |
48 | (4, 'Scheduled'), |
|
56 | (4, 'Scheduled'), | |
49 | ) |
|
57 | ) | |
50 | # Create your models here. |
|
58 | # Create your models here. | |
51 |
|
59 | |||
52 |
|
60 | |||
53 | class Location(models.Model): |
|
61 | class Location(models.Model): | |
54 |
|
62 | |||
55 | name = models.CharField(max_length = 30) |
|
63 | name = models.CharField(max_length = 30) | |
56 | description = models.TextField(blank=True, null=True) |
|
64 | description = models.TextField(blank=True, null=True) | |
57 |
|
65 | |||
58 | class Meta: |
|
66 | class Meta: | |
59 | db_table = 'db_location' |
|
67 | db_table = 'db_location' | |
60 |
|
68 | |||
61 | def __unicode__(self): |
|
69 | def __unicode__(self): | |
62 | return u'%s' % self.name |
|
70 | return u'%s' % self.name | |
63 |
|
71 | |||
64 | class DeviceType(models.Model): |
|
72 | class DeviceType(models.Model): | |
65 |
|
73 | |||
66 | name = models.CharField(max_length = 10, choices = DEV_TYPES, default = 'rc') |
|
74 | name = models.CharField(max_length = 10, choices = DEV_TYPES, default = 'rc') | |
67 | description = models.TextField(blank=True, null=True) |
|
75 | description = models.TextField(blank=True, null=True) | |
68 |
|
76 | |||
69 | class Meta: |
|
77 | class Meta: | |
70 | db_table = 'db_device_types' |
|
78 | db_table = 'db_device_types' | |
71 |
|
79 | |||
72 | def __unicode__(self): |
|
80 | def __unicode__(self): | |
73 | return u'%s' % self.get_name_display() |
|
81 | return u'%s' % self.get_name_display() | |
74 |
|
82 | |||
75 | class Device(models.Model): |
|
83 | class Device(models.Model): | |
76 |
|
84 | |||
77 | device_type = models.ForeignKey(DeviceType, on_delete=models.CASCADE) |
|
85 | device_type = models.ForeignKey(DeviceType, on_delete=models.CASCADE) | |
78 | location = models.ForeignKey(Location, on_delete=models.CASCADE) |
|
86 | location = models.ForeignKey(Location, on_delete=models.CASCADE) | |
79 |
|
87 | |||
80 | name = models.CharField(max_length=40, default='') |
|
88 | name = models.CharField(max_length=40, default='') | |
81 | ip_address = models.GenericIPAddressField(protocol='IPv4', default='0.0.0.0') |
|
89 | ip_address = models.GenericIPAddressField(protocol='IPv4', default='0.0.0.0') | |
82 | port_address = models.PositiveSmallIntegerField(default=2000) |
|
90 | port_address = models.PositiveSmallIntegerField(default=2000) | |
83 | description = models.TextField(blank=True, null=True) |
|
91 | description = models.TextField(blank=True, null=True) | |
84 | status = models.PositiveSmallIntegerField(default=0, choices=DEV_STATES) |
|
92 | status = models.PositiveSmallIntegerField(default=0, choices=DEV_STATES) | |
85 |
|
93 | |||
86 | class Meta: |
|
94 | class Meta: | |
87 | db_table = 'db_devices' |
|
95 | db_table = 'db_devices' | |
88 |
|
96 | |||
89 | def __unicode__(self): |
|
97 | def __unicode__(self): | |
90 | return u'%s | %s' % (self.name, self.ip_address) |
|
98 | return u'%s | %s' % (self.name, self.ip_address) | |
91 |
|
99 | |||
92 | def get_status(self): |
|
100 | def get_status(self): | |
93 |
|
101 | |||
94 | return self.status |
|
102 | return self.status | |
95 |
|
103 | |||
96 |
|
104 | |||
97 | class Campaign(models.Model): |
|
105 | class Campaign(models.Model): | |
98 |
|
106 | |||
99 | template = models.BooleanField(default=False) |
|
107 | template = models.BooleanField(default=False) | |
100 |
|
108 | |||
101 | name = models.CharField(max_length=40, unique=True) |
|
109 | name = models.CharField(max_length=40, unique=True) | |
102 | start_date = models.DateTimeField(blank=True, null=True) |
|
110 | start_date = models.DateTimeField(blank=True, null=True) | |
103 | end_date = models.DateTimeField(blank=True, null=True) |
|
111 | end_date = models.DateTimeField(blank=True, null=True) | |
104 | tags = models.CharField(max_length=40) |
|
112 | tags = models.CharField(max_length=40) | |
105 | description = models.TextField(blank=True, null=True) |
|
113 | description = models.TextField(blank=True, null=True) | |
106 |
|
114 | |||
107 | class Meta: |
|
115 | class Meta: | |
108 | db_table = 'db_campaigns' |
|
116 | db_table = 'db_campaigns' | |
109 |
|
117 | |||
110 | def __unicode__(self): |
|
118 | def __unicode__(self): | |
111 | return u'%s' % (self.name) |
|
119 | return u'%s' % (self.name) | |
112 |
|
120 | |||
113 | # class Radar(models.Model): |
|
121 | # class Radar(models.Model): | |
114 | # |
|
122 | # | |
115 | # # name = models.CharField(max_length = 30) |
|
123 | # # name = models.CharField(max_length = 30) | |
116 | # experiment = models.ForeignKey('Experiment', on_delete=models.CASCADE) |
|
124 | # experiment = models.ForeignKey('Experiment', on_delete=models.CASCADE) | |
117 | # location = models.OneToOneField('Location', on_delete=models.CASCADE) |
|
125 | # location = models.OneToOneField('Location', on_delete=models.CASCADE) | |
118 | # status = models.PositiveSmallIntegerField(default=0, choices=RADAR_STATES) |
|
126 | # status = models.PositiveSmallIntegerField(default=0, choices=RADAR_STATES) | |
119 | # |
|
127 | # | |
120 | # class Meta: |
|
128 | # class Meta: | |
121 | # db_table = 'db_radar' |
|
129 | # db_table = 'db_radar' | |
122 | # |
|
130 | # | |
123 | # def __unicode__(self): |
|
131 | # def __unicode__(self): | |
124 | # return u'%s' % self.location |
|
132 | # return u'%s' % self.location | |
125 |
|
133 | |||
|
134 | #class RunningExperiment(models.Model): | |||
|
135 | # radar = models.OneToOneField('Location', on_delete=models.CASCADE) | |||
|
136 | # running_experiment = models.OneToOneField('Experiment', on_delete=models.CASCADE) | |||
|
137 | # status = models.PositiveSmallIntegerField(default=0, choices=RADAR_STATES) | |||
|
138 | ||||
126 |
|
139 | |||
127 | class Experiment(models.Model): |
|
140 | class Experiment(models.Model): | |
128 |
|
141 | |||
129 | template = models.BooleanField(default=False) |
|
142 | template = models.BooleanField(default=False) | |
130 |
|
143 | |||
131 | campaign = models.ForeignKey('Campaign', null=True, blank=True, on_delete=models.CASCADE) |
|
144 | campaign = models.ForeignKey('Campaign', null=True, blank=True, on_delete=models.CASCADE) | |
132 | location = models.ForeignKey('Location', null=True, blank=True, on_delete=models.CASCADE) |
|
145 | location = models.ForeignKey('Location', null=True, blank=True, on_delete=models.CASCADE) | |
133 |
|
146 | |||
134 | name = models.CharField(max_length=40, default='') |
|
147 | name = models.CharField(max_length=40, default='') | |
135 | start_time = models.TimeField(default='00:00:00') |
|
148 | start_time = models.TimeField(default='00:00:00') | |
136 | end_time = models.TimeField(default='23:59:59') |
|
149 | end_time = models.TimeField(default='23:59:59') | |
137 |
|
150 | |||
138 | class Meta: |
|
151 | class Meta: | |
139 | db_table = 'db_experiments' |
|
152 | db_table = 'db_experiments' | |
140 |
|
153 | |||
141 | def __unicode__(self): |
|
154 | def __unicode__(self): | |
142 | return u'%s' % (self.name) |
|
155 | return u'%s' % (self.name) | |
143 |
|
156 | |||
144 | class Configuration(PolymorphicModel): |
|
157 | class Configuration(PolymorphicModel): | |
145 |
|
158 | |||
146 | template = models.BooleanField(default=False) |
|
159 | template = models.BooleanField(default=False) | |
147 |
|
160 | |||
148 | name = models.CharField(verbose_name="Configuration Name", max_length=40, default='') |
|
161 | name = models.CharField(verbose_name="Configuration Name", max_length=40, default='') | |
149 |
|
162 | |||
150 | experiment = models.ForeignKey('Experiment', null=True, blank=True, on_delete=models.CASCADE) |
|
163 | experiment = models.ForeignKey('Experiment', null=True, blank=True, on_delete=models.CASCADE) | |
151 | device = models.ForeignKey(Device, on_delete=models.CASCADE) |
|
164 | device = models.ForeignKey(Device, on_delete=models.CASCADE) | |
152 |
|
165 | |||
153 | type = models.PositiveSmallIntegerField(default=0, choices=CONF_TYPES) |
|
166 | type = models.PositiveSmallIntegerField(default=0, choices=CONF_TYPES) | |
154 |
|
167 | |||
155 | created_date = models.DateTimeField(auto_now_add=True) |
|
168 | created_date = models.DateTimeField(auto_now_add=True) | |
156 | programmed_date = models.DateTimeField(auto_now=True) |
|
169 | programmed_date = models.DateTimeField(auto_now=True) | |
157 |
|
170 | |||
158 | parameters = models.TextField(default='{}') |
|
171 | parameters = models.TextField(default='{}') | |
159 |
|
172 | |||
160 | message = "" |
|
173 | message = "" | |
161 |
|
174 | |||
162 | class Meta: |
|
175 | class Meta: | |
163 | db_table = 'db_configurations' |
|
176 | db_table = 'db_configurations' | |
164 |
|
177 | |||
165 | def __unicode__(self): |
|
178 | def __unicode__(self): | |
166 | return u'[%s, %s]: %s' % (self.experiment.name, |
|
179 | return u'[%s, %s]: %s' % (self.experiment.name, | |
167 | self.device.name, |
|
180 | self.device.name, | |
168 | self.name) |
|
181 | self.name) | |
169 |
|
182 | |||
170 | def parms_to_dict(self): |
|
183 | def parms_to_dict(self): | |
171 |
|
184 | |||
172 | parameters = {} |
|
185 | parameters = {} | |
173 |
|
186 | |||
174 | for key in self.__dict__.keys(): |
|
187 | for key in self.__dict__.keys(): | |
175 | parameters[key] = getattr(self, key) |
|
188 | parameters[key] = getattr(self, key) | |
176 |
|
189 | |||
177 | return parameters |
|
190 | return parameters | |
178 |
|
191 | |||
179 | def parms_to_text(self): |
|
192 | def parms_to_text(self): | |
180 |
|
193 | |||
181 | raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper() |
|
194 | raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper() | |
182 |
|
195 | |||
183 | return '' |
|
196 | return '' | |
184 |
|
197 | |||
185 | def parms_to_binary(self): |
|
198 | def parms_to_binary(self): | |
186 |
|
199 | |||
187 | raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper() |
|
200 | raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper() | |
188 |
|
201 | |||
189 | return '' |
|
202 | return '' | |
190 |
|
203 | |||
191 | def dict_to_parms(self, parameters): |
|
204 | def dict_to_parms(self, parameters): | |
192 |
|
205 | |||
193 | if type(parameters) != type({}): |
|
206 | if type(parameters) != type({}): | |
194 | return |
|
207 | return | |
195 |
|
208 | |||
196 | for key in parameters.keys(): |
|
209 | for key in parameters.keys(): | |
197 | setattr(self, key, parameters[key]) |
|
210 | setattr(self, key, parameters[key]) | |
198 |
|
211 | |||
199 | def export_to_file(self, format="json"): |
|
212 | def export_to_file(self, format="json"): | |
200 |
|
213 | |||
201 | import json |
|
214 | import json | |
202 |
|
215 | |||
203 | content_type = '' |
|
216 | content_type = '' | |
204 |
|
217 | |||
205 | if format == 'text': |
|
218 | if format == 'text': | |
206 | content_type = 'text/plain' |
|
219 | content_type = 'text/plain' | |
207 | filename = '%s_%s.%s' %(self.device.device_type.name, self.name, self.device.device_type.name) |
|
220 | filename = '%s_%s.%s' %(self.device.device_type.name, self.name, self.device.device_type.name) | |
208 | content = self.parms_to_text() |
|
221 | content = self.parms_to_text() | |
209 |
|
222 | |||
210 | if format == 'binary': |
|
223 | if format == 'binary': | |
211 | content_type = 'application/octet-stream' |
|
224 | content_type = 'application/octet-stream' | |
212 | filename = '%s_%s.bin' %(self.device.device_type.name, self.name) |
|
225 | filename = '%s_%s.bin' %(self.device.device_type.name, self.name) | |
213 | content = self.parms_to_binary() |
|
226 | content = self.parms_to_binary() | |
214 |
|
227 | |||
215 | if not content_type: |
|
228 | if not content_type: | |
216 | content_type = 'application/json' |
|
229 | content_type = 'application/json' | |
217 | filename = '%s_%s.json' %(self.device.device_type.name, self.name) |
|
230 | filename = '%s_%s.json' %(self.device.device_type.name, self.name) | |
218 | content = json.dumps(self.parms_to_dict()) |
|
231 | content = json.dumps(self.parms_to_dict()) | |
219 |
|
232 | |||
220 | fields = {'content_type':content_type, |
|
233 | fields = {'content_type':content_type, | |
221 | 'filename':filename, |
|
234 | 'filename':filename, | |
222 | 'content':content |
|
235 | 'content':content | |
223 | } |
|
236 | } | |
224 |
|
237 | |||
225 | return fields |
|
238 | return fields | |
226 |
|
239 | |||
227 | def import_from_file(self, fp): |
|
240 | def import_from_file(self, fp): | |
228 |
|
241 | |||
229 | import os, json |
|
242 | import os, json | |
230 |
|
243 | |||
231 | parms = {} |
|
244 | parms = {} | |
232 |
|
245 | |||
233 | path, ext = os.path.splitext(fp.name) |
|
246 | path, ext = os.path.splitext(fp.name) | |
234 |
|
247 | |||
235 | if ext == '.json': |
|
248 | if ext == '.json': | |
236 | parms = json.load(fp) |
|
249 | parms = json.load(fp) | |
237 |
|
250 | |||
238 | return parms |
|
251 | return parms | |
239 |
|
252 | |||
240 | def status_device(self): |
|
253 | def status_device(self): | |
241 |
|
254 | |||
242 | raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper() |
|
255 | raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper() | |
243 |
|
256 | |||
244 | return None |
|
257 | return None | |
245 |
|
258 | |||
246 | def stop_device(self): |
|
259 | def stop_device(self): | |
247 |
|
260 | |||
248 | raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper() |
|
261 | raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper() | |
249 |
|
262 | |||
250 | return None |
|
263 | return None | |
251 |
|
264 | |||
252 | def start_device(self): |
|
265 | def start_device(self): | |
253 |
|
266 | |||
254 | raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper() |
|
267 | raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper() | |
255 |
|
268 | |||
256 | return None |
|
269 | return None | |
257 |
|
270 | |||
258 | def write_device(self, parms): |
|
271 | def write_device(self, parms): | |
259 |
|
272 | |||
260 | raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper() |
|
273 | raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper() | |
261 |
|
274 | |||
262 | return None |
|
275 | return None | |
263 |
|
276 | |||
264 | def read_device(self): |
|
277 | def read_device(self): | |
265 |
|
278 | |||
266 | raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper() |
|
279 | raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper() | |
267 |
|
280 | |||
268 | return None |
|
281 | return None | |
269 |
|
282 | |||
270 | def get_absolute_url(self): |
|
283 | def get_absolute_url(self): | |
271 | return reverse('url_%s_conf' % self.device.device_type.name, args=[str(self.id)]) |
|
284 | return reverse('url_%s_conf' % self.device.device_type.name, args=[str(self.id)]) | |
272 |
|
285 | |||
273 | def get_absolute_url_edit(self): |
|
286 | def get_absolute_url_edit(self): | |
274 | return reverse('url_edit_%s_conf' % self.device.device_type.name, args=[str(self.id)]) |
|
287 | return reverse('url_edit_%s_conf' % self.device.device_type.name, args=[str(self.id)]) | |
275 |
|
288 | |||
276 | def get_absolute_url_import(self): |
|
289 | def get_absolute_url_import(self): | |
277 | return reverse('url_import_dev_conf', args=[str(self.id)]) |
|
290 | return reverse('url_import_dev_conf', args=[str(self.id)]) | |
278 |
|
291 | |||
279 | def get_absolute_url_export(self): |
|
292 | def get_absolute_url_export(self): | |
280 | return reverse('url_export_dev_conf', args=[str(self.id)]) |
|
293 | return reverse('url_export_dev_conf', args=[str(self.id)]) | |
281 |
|
294 | |||
282 | def get_absolute_url_write(self): |
|
295 | def get_absolute_url_write(self): | |
283 | return reverse('url_write_dev_conf', args=[str(self.id)]) |
|
296 | return reverse('url_write_dev_conf', args=[str(self.id)]) | |
284 |
|
297 | |||
285 | def get_absolute_url_read(self): |
|
298 | def get_absolute_url_read(self): | |
286 | return reverse('url_read_dev_conf', args=[str(self.id)]) |
|
299 | return reverse('url_read_dev_conf', args=[str(self.id)]) | |
287 |
|
300 | |||
288 | def get_absolute_url_start(self): |
|
301 | def get_absolute_url_start(self): | |
289 | return reverse('url_start_dev_conf', args=[str(self.id)]) |
|
302 | return reverse('url_start_dev_conf', args=[str(self.id)]) | |
290 |
|
303 | |||
291 | def get_absolute_url_stop(self): |
|
304 | def get_absolute_url_stop(self): | |
292 | return reverse('url_stop_dev_conf', args=[str(self.id)]) |
|
305 | return reverse('url_stop_dev_conf', args=[str(self.id)]) | |
293 |
|
306 | |||
294 | def get_absolute_url_status(self): |
|
307 | def get_absolute_url_status(self): | |
295 | return reverse('url_status_dev_conf', args=[str(self.id)]) No newline at end of file |
|
308 | return reverse('url_status_dev_conf', args=[str(self.id)]) |
General Comments 0
You need to be logged in to leave comments.
Login now