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