##// END OF EJS Templates
radarsys
RSS
Standardize jars functions: start, stop, write, read, status...
Fiorella Quino -
r209:90fa9a52ca2f
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,273 +1,323
1 1 from django.db import models
2 2 from apps.main.models import Configuration
3 3 from django.core.validators import MinValueValidator, MaxValueValidator
4 4 from django.core.urlresolvers import reverse
5 5 from devices.jars import api
6 6
7 7 from apps.rc.models import RCConfiguration
8 8
9 9 import json
10 10 # Create your models here.
11 11
12 12 EXPERIMENT_TYPE = (
13 13 (0, 'RAW_DATA'),
14 14 (1, 'PDATA'),
15 15 )
16 16
17 17 DATA_TYPE = (
18 18 (0, 'SHORT'),
19 19 (1, 'FLOAT'),
20 20 )
21 21
22 22 class JARSfilter(models.Model):
23 23
24 24 JARS_NBITS = 32
25 25
26 26 name = models.CharField(max_length=60, unique=True, default='')
27 27 clock = models.FloatField(verbose_name='Clock In (MHz)',validators=[MinValueValidator(5), MaxValueValidator(75)], null=True, default=60)
28 28 mult = models.PositiveIntegerField(verbose_name='Multiplier',validators=[MinValueValidator(1), MaxValueValidator(20)], default=5)
29 29 fch = models.DecimalField(verbose_name='Frequency (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, null=True, default=49.9200)
30 30 fch_decimal = models.BigIntegerField(verbose_name='Frequency (Decimal)',validators=[MinValueValidator(0), MaxValueValidator(2**JARS_NBITS-1)], null=True, default=721554505)
31 31 filter_fir = models.PositiveIntegerField(verbose_name='FIR Filter',validators=[MinValueValidator(1), MaxValueValidator(20)], default = 6)
32 32 filter_2 = models.PositiveIntegerField(verbose_name='Filter 2',validators=[MinValueValidator(1), MaxValueValidator(20)], default = 10)
33 33 filter_5 = models.PositiveIntegerField(verbose_name='Filter 5',validators=[MinValueValidator(1), MaxValueValidator(20)], default = 1)
34 34 speed = models.PositiveIntegerField(verbose_name='Speed',validators=[MinValueValidator(0), MaxValueValidator(100000)], default = 0)
35 35
36 36 class Meta:
37 37 db_table = 'jars_filters'
38 38
39 39 def __unicode__(self):
40 40 return u'%s' % (self.name)
41 41
42 42 def parms_to_dict(self):
43 43
44 44 parameters = {}
45 45
46 46 parameters['name'] = self.name
47 47 parameters['clock'] = float(self.clock)
48 48 parameters['mult'] = int(self.mult)
49 49 parameters['fch'] = float(self.fch)
50 50 parameters['fch_decimal'] = int(self.fch)
51 51 parameters['filter_fir'] = int(self.filter_fir)
52 52 parameters['filter_2'] = int(self.filter_2)
53 53 parameters['filter_5'] = int(self.filter_5)
54 54 parameters['speed'] = int(self.speed)
55 55
56 56 return parameters
57 57
58 58 def dict_to_parms(self, parameters):
59 59
60 60 self.name = parameters['name']
61 61 self.clock = parameters['clock']
62 62 self.mult = parameters['mult']
63 63 self.fch = parameters['fch']
64 64 self.fch_decimal = parameters['fch_decimal']
65 65 self.filter_fir = parameters['filter_fir']
66 66 self.filter_2 = parameters['filter_2']
67 67 self.filter_5 = parameters['filter_5']
68 68 self.speed = parameters['speed']
69 69
70 70
71 71 class JARSConfiguration(Configuration):
72 72
73 73 ADC_RESOLUTION = 8
74 74 PCI_DIO_BUSWIDTH = 32
75 75 HEADER_VERSION = 1103
76 76 BEGIN_ON_START = True
77 77 REFRESH_RATE = 1
78 78
79 79 #rc = models.ForeignKey(RCConfiguration, on_delete=models.CASCADE, null=True)
80 80 exp_type = models.PositiveIntegerField(verbose_name='Experiment Type', choices=EXPERIMENT_TYPE, default=0)
81 81 cards_number = models.PositiveIntegerField(verbose_name='Number of Cards', validators=[MinValueValidator(1), MaxValueValidator(4)], default = 1)
82 82 channels_number = models.PositiveIntegerField(verbose_name='Number of Channels', validators=[MinValueValidator(1), MaxValueValidator(8)], default = 5)
83 83 channels = models.CharField(verbose_name='Channels', max_length=15, default = '1,2,3,4,5')
84 84 rd_directory = models.CharField(verbose_name='Raw Data Directory', max_length=200, default='', blank=True, null=True)
85 85 pd_directory = models.CharField(verbose_name='Process Data Directory', max_length=200, default='', blank=True, null=True)
86 86 #raw_data_blocks = models.PositiveIntegerField(verbose_name='Raw Data Blocks', validators=[MaxValueValidator(5000)], default=120)
87 87 data_type = models.PositiveIntegerField(verbose_name='Data Type', choices=DATA_TYPE, default=0)
88 88 acq_profiles = models.PositiveIntegerField(verbose_name='Acquired Profiles', validators=[MaxValueValidator(5000)], default=400)
89 89 profiles_block = models.PositiveIntegerField(verbose_name='Profiles Per Block', validators=[MaxValueValidator(5000)], default=400)
90 90 ftp_interval = models.PositiveIntegerField(verbose_name='FTP Interval', default=60)
91 91 fftpoints = models.PositiveIntegerField(verbose_name='FFT Points',default=16)
92 92 cohe_integr_str = models.PositiveIntegerField(verbose_name='Coh. Int. Stride',validators=[MinValueValidator(1)], default=30)
93 93 cohe_integr = models.PositiveIntegerField(verbose_name='Coherent Integrations',validators=[MinValueValidator(1)], default=30)
94 94 incohe_integr = models.PositiveIntegerField(verbose_name='Incoherent Integrations',validators=[MinValueValidator(1)], default=30)
95 95 filter = models.ForeignKey(JARSfilter, on_delete=models.CASCADE, null=True)
96 96 spectral_number = models.PositiveIntegerField(verbose_name='# Spectral Combinations',validators=[MinValueValidator(1)], default=1)
97 97 spectral = models.CharField(verbose_name='Combinations', max_length=5000, default = '[0, 0],')
98 98 create_directory = models.BooleanField(verbose_name='Create Directory Per Day', default=True)
99 99 include_expname = models.BooleanField(verbose_name='Experiment Name in Directory', default=True)
100 100 #acq_link = models.BooleanField(verbose_name='Acquisition Link', default=True)
101 101 #view_raw_data = models.BooleanField(verbose_name='View Raw Data', default=True)
102 102 save_ch_dc = models.BooleanField(verbose_name='Save Channels DC', default=True)
103 103 save_data = models.BooleanField(verbose_name='Save Data', default=True)
104 104 filter_parms = models.CharField(max_length=10000, default='{}')
105 105
106 106 class Meta:
107 107 db_table = 'jars_configurations'
108 108
109 109 def parms_to_dict(self):
110 110
111 111 parameters = {}
112 112
113 113 parameters['device_id'] = self.device.id
114 114 parameters['name'] = self.name
115 115 #parameters['rc'] = self.rc.name
116 116 parameters['exp_type'] = self.exp_type
117 117 parameters['exptype'] = EXPERIMENT_TYPE[self.exp_type][1]
118 118 parameters['cards_number'] = self.cards_number
119 119 parameters['channels_number'] = self.channels_number
120 120 parameters['channels'] = self.channels
121 121 parameters['rd_directory'] = self.rd_directory
122 122 #parameters['raw_data_blocks'] = self.raw_data_blocks
123 123 parameters['data_type'] = self.data_type
124 124 parameters['cohe_integr_str'] = self.cohe_integr_str
125 125 parameters['acq_profiles'] = self.acq_profiles
126 126 parameters['profiles_block'] = self.profiles_block
127 127 parameters['ftp_interval'] = self.ftp_interval
128 128 parameters['fftpoints'] = self.fftpoints
129 129 parameters['cohe_integr'] = self.cohe_integr
130 130 #parameters['incohe_integr'] = self.incohe_integr
131 131 parameters['filter'] = self.filter.name
132 132 parameters['filter_parms'] = self.filter_parms
133 133 #parameters['spectral_number'] = self.spectral_number
134 134 #parameters['spectral'] = self.spectral
135 135 parameters['create_directory'] = bool(self.create_directory)
136 136 parameters['include_expname'] = bool(self.include_expname)
137 137 #parameters['acq_link'] = bool(self.acq_link)
138 138 #parameters['view_raw_data'] = bool(self.view_raw_data)
139 139 parameters['save_ch_dc'] = bool(self.save_ch_dc)
140 140 parameters['save_data'] = bool(self.save_data)
141 141
142 142 if parameters['exptype'] == 'PDATA':
143 143 parameters['incohe_integr'] = self.incohe_integr
144 144 parameters['spectral_number'] = self.spectral_number
145 145 parameters['spectral'] = self.spectral
146 146 parameters['pd_directory'] = self.pd_directory
147 147
148 148 return parameters
149 149
150 150 def add_parms_to_filter(self):
151 151 self.filter_parms = self.filter.parms_to_dict()
152 152 self.save()
153 153
154 154 def dict_to_parms(self, parameters):
155 155
156 156 self.name = parameters['name']
157 157 self.device.id = int(parameters['device_id'])
158 158
159 159 self.exp_type = int(parameters['exp_type'])
160 160 if parameters['exptype'] == 'PDATA':
161 161 self.incohe_integr = parameters['incohe_integr']
162 162 self.spectral_number = parameters['spectral_number']
163 163 self.spectral = parameters['spectral']
164 164 self.pd_directory = parameters['pd_directory']
165 165
166 166 self.cards_number = int(parameters['cards_number'])
167 167 self.channels_number = int(parameters['channels_number'])
168 168 self.channels = parameters['channels']
169 169 self.rd_directory = parameters['rd_directory']
170 170 #self.raw_data_blocks = parameters['raw_data_blocks']
171 171 self.data_type = parameters['data_type']
172 172 self.cohe_integr_str = parameters['cohe_integr_str']
173 173 self.acq_profiles = parameters['acq_profiles']
174 174 self.profiles_block = parameters['profiles_block']
175 175 self.ftp_interval = parameters['ftp_interval']
176 176 self.fftpoints = parameters['fftpoints']
177 177 self.cohe_integr = parameters['cohe_integr']
178 178
179 179 filter_name = parameters['filter']
180 180 self.filter = JARSfilter.objects.get(name=filter_name)
181 181 self.add_parms_to_filter()
182 182 self.filter_parms = parameters['filter_parms']
183 183
184 184 self.create_directory = bool(parameters['create_directory'])
185 185 self.include_expname = bool(parameters['include_expname'])
186 186 #self.acq_link = bool(parameters['acq_link'])
187 187 #self.view_raw_data = bool(parameters['view_raw_data'])
188 188 self.save_ch_dc = bool(parameters['save_ch_dc'])
189 189 self.save_data = bool(parameters['save_data'])
190 190
191 191 def status_device(self):
192 192
193 answer = api.status(self.device.ip_address,self.device.port_address)
194 self.device.status = int(answer[0])
195 self.message = answer[2:]
196 self.device.save()
193 try:
194 answer = api.status(self.device.ip_address,self.device.port_address)
195 self.device.status = int(answer[0])
196 self.device.save()
197 self.message = answer[2:]
198 if self.device.status == 0:
199 return False
197 200
198 return self.device.status
201 except Exception as e:
202 self.device.status = 0
203 self.message = str(e)
204 self.device.save()
205 return False
206
207 return True
199 208
200 209 def stop_device(self):
201 210
202 answer = api.stop(self.device.ip_address,self.device.port_address)
203 self.device.status = int(answer[0])
204 self.message = answer[2:]
205 self.device.save()
211 try:
212 answer = api.stop(self.device.ip_address,self.device.port_address)
213 self.device.status = int(answer[0])
214 self.message = answer[2:]
215 self.device.save()
216 if self.device.status == 0 or self.device.status == 1:
217 return False
206 218
207 return self.device.status
219 except Exception as e:
220 self.device.status = 0
221 self.message = str(e)
222 self.device.save()
223 return False
224
225 return True
208 226
209 227 def read_device(self):
210 228
211 answer = api.read(self.device.ip_address,self.device.port_address)
212 self.device.status = int(answer[0])
213 229 try:
230 answer = api.read(self.device.ip_address,self.device.port_address)
231 self.device.status = int(answer[0])
232 self.device.save()
233 self.message = answer[2:]
234 if self.device.status == 1:
235 return False
214 236 data = json.loads(answer[2:])
215 237 parms = data['configurations']['jars']
238
216 239 except:
217 240 self.device.status = 0
218 241 self.device.save()
219 242 self.message = 'Could not read JARS configuration.'
220 return ''
243 return False
221 244
222 245 #self.dict_to_parms(parms)
223 246 self.message = 'Current JARS configuration was read successfully.'
224 247 self.device.save()
225 248 return parms
226 249
227 250
228 251 def write_device(self):
229 252
253 if self.device.status == 3:
254 self.message = 'Could not configure device. Software Acquisition is running'
255 return False
256
230 257 data = self.experiment.parms_to_dict()
231 258 data = json.loads(data)
232 259 data['configurations']['dds'] =''
233 260 data['configurations']['cgs'] =''
234 261 data['configurations']['rc']['pulses']=''
235 262 data['configurations']['rc']['delays']=''
236 263 json_data = json.dumps(data)
237 264
238 answer = api.configure(self.device.ip_address,self.device.port_address,json_data)
239 #print answer
240 self.device.status = int(answer[0])
241 self.message = answer[2:]
265 try:
266 answer = api.configure(self.device.ip_address,self.device.port_address,json_data)
267 self.device.status = int(answer[0])
268 self.message = answer[2:]
269 self.device.save()
270 if self.device.status == 1:
271 return False
272 if self.device.status == 3:
273 return False
242 274
243 self.device.save()
275 except Exception as e:
276 self.device.status = 0
277 self.message = str(e)
278 self.device.save()
279 return False
244 280
245 return self.device.status
281 return True
246 282
247 283
248 284 def start_device(self):
249 285
250 self.write_device()
286 try:
287 answer = api.start(self.device.ip_address,self.device.port_address)
288 self.device.status = int(answer[0])
289 self.message = answer[2:]
290 self.device.save()
291 if self.device.status == 1:
292 return False
293
294 except Exception as e:
295 self.device.status = 0
296 self.message = str(e)
297 self.device.save()
298 return False
299
300 return True
251 301
252 302
253 303 def echo(self):
254 304
255 305 answer = api.echo(self.device.ip_address,self.device.port_address,'(=')
256 306 #print answer
257 307 self.device.status = int(answer[0])
258 308 self.message = answer[2:]
259 309
260 310 self.device.save()
261 311
262 312 return #self.device.status
263 313
264 314 def update_from_file(self, parameters):
265 315
266 316 self.dict_to_parms(parameters)
267 317 self.save()
268 318
269 319 def get_absolute_url_import(self):
270 320 return reverse('url_import_jars_conf', args=[str(self.id)])
271 321
272 322 def get_absolute_url_read(self):
273 323 return reverse('url_read_jars_conf', args=[str(self.id)])
Show file before | Show file after | Hide comments
@@ -1,247 +1,247
1 1 from django.shortcuts import render_to_response
2 2 from django.template import RequestContext
3 3 from django.shortcuts import redirect, render, get_object_or_404
4 4 from django.contrib import messages
5 5
6 6 from apps.main.models import Device
7 7 from apps.main.views import sidebar
8 8
9 9 from .models import JARSConfiguration, JARSfilter
10 10 from .forms import JARSConfigurationForm, JARSfilterForm, JARSImportForm
11 11 # Create your views here.
12 12
13 13 def jars_conf(request, id_conf):
14
14
15 15 conf = get_object_or_404(JARSConfiguration, pk=id_conf)
16
16
17 17 ip=conf.device.ip_address
18 18 port=conf.device.port_address
19
19
20 20 kwargs = {}
21 21 kwargs['status'] = conf.device.get_status_display()
22
23
22
23
24 24 kwargs['dev_conf'] = conf
25 25 kwargs['dev_conf_keys'] = ['name',
26 26 'cards_number', 'channels_number', 'channels',
27 'rd_directory', 'pd_directory',
27 'rd_directory', 'pd_directory',
28 28 'data_type',
29 29 'acq_profiles', 'profiles_block', 'ftp_interval', 'fftpoints',
30 30 'cohe_integr_str',
31 31 'incohe_integr', 'cohe_integr', 'filter', 'spectral_number',
32 32 'spectral', 'create_directory', 'include_expname',
33 33 'save_ch_dc', 'save_data']
34
34
35 35 kwargs['title'] = 'JARS Configuration'
36 36 kwargs['suptitle'] = 'Details'
37
37
38 38 kwargs['button'] = 'Edit Configuration'
39
39
40 40 #kwargs['no_play'] = True
41
42 kwargs['only_stop'] = True
43
41
42 #kwargs['only_stop'] = True
43
44 44 ###### SIDEBAR ######
45 45 kwargs.update(sidebar(conf=conf))
46
46
47 47 return render(request, 'jars_conf.html', kwargs)
48 48
49 49 def jars_conf_edit(request, id_conf):
50
50
51 51 conf = get_object_or_404(JARSConfiguration, pk=id_conf)
52
52
53 53 if request.method=='GET':
54 54 form = JARSConfigurationForm(instance=conf)
55
55
56 56 if request.method=='POST':
57 57 form = JARSConfigurationForm(request.POST, instance=conf)
58
58
59 59 if form.is_valid():
60 60 conf = form.save(commit=False)
61 61 conf.save()
62 62 return redirect('url_jars_conf', id_conf=conf.id)
63
63
64 64 ##ERRORS
65
65
66 66 kwargs = {}
67
67
68 68 kwargs['filter_id'] = conf.filter.id
69 69 kwargs['id_dev'] = conf.id
70 70 kwargs['form'] = form
71 71 kwargs['title'] = 'Device Configuration'
72 72 kwargs['suptitle'] = 'Edit'
73 73 kwargs['button'] = 'Save'
74
74
75 75 return render(request, 'jars_conf_edit.html', kwargs)
76 76
77 77 def import_file(request, conf_id):
78
78
79 79 conf = get_object_or_404(JARSConfiguration, pk=conf_id)
80 80 if request.method=='POST':
81 81 form = JARSImportForm(request.POST, request.FILES)
82 if form.is_valid():
82 if form.is_valid():
83 83 try:
84 84 parms = conf.import_from_file(request.FILES['file_name'])
85
85
86 86 if parms:
87 87 conf.update_from_file(parms)
88 88 messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
89 89 return redirect(conf.get_absolute_url_edit())
90
91 except Exception as e:
90
91 except Exception as e:
92 92 messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], e))
93
93
94 94 else:
95 95 messages.warning(request, 'Your current configuration will be replaced')
96 form = JARSImportForm()
97
96 form = JARSImportForm()
97
98 98 kwargs = {}
99 99 kwargs['form'] = form
100 100 kwargs['title'] = 'JARS Configuration'
101 101 kwargs['suptitle'] = 'Import file'
102 102 kwargs['button'] = 'Upload'
103 103 kwargs['previous'] = conf.get_absolute_url()
104
104
105 105 return render(request, 'jars_import.html', kwargs)
106 106
107 107 def read_conf(request, conf_id):
108
108
109 109 conf = get_object_or_404(JARSConfiguration, pk=conf_id)
110 110 #filter = get_object_or_404(JARSfilter, pk=filter_id)
111
111
112 112 if request.method=='GET':
113
113
114 114 parms = conf.read_device()
115 115 conf.status_device()
116
116
117 117 if not parms:
118 118 messages.error(request, conf.message)
119 119 return redirect(conf.get_absolute_url())
120
120
121 121 form = JARSConfigurationForm(initial=parms, instance=conf)
122
122
123 123 if request.method=='POST':
124 124 form = JARSConfigurationForm(request.POST, instance=conf)
125
125
126 126 if form.is_valid():
127 127 form.save()
128 128 return redirect(conf.get_absolute_url())
129
129
130 130 messages.error(request, "Parameters could not be saved")
131
131
132 132 kwargs = {}
133 133 kwargs['id_dev'] = conf.id
134 134 kwargs['filter_id'] = conf.filter.id
135 135 kwargs['form'] = form
136 136 kwargs['title'] = 'Device Configuration'
137 137 kwargs['suptitle'] = 'Parameters read from device'
138 138 kwargs['button'] = 'Save'
139
139
140 140 ###### SIDEBAR ######
141 141 kwargs.update(sidebar(conf=conf))
142
142
143 143 return render(request, 'jars_conf_edit.html', kwargs)
144 144
145 145 def view_filter(request, conf_id, filter_id):
146
146
147 147 conf = get_object_or_404(JARSConfiguration, pk=conf_id)
148 148 filter = get_object_or_404(JARSfilter, pk=filter_id)
149
149
150 150 filter_parms = eval(conf.filter_parms)
151 151 filter.name = filter_parms['name']
152 152 filter.clock = filter_parms['clock']
153 153 filter.mult = filter_parms['mult']
154 154 filter.fch = filter_parms['fch']
155 155 filter.fch_decimal = filter_parms['fch_decimal']
156 156 filter.filter_fir = filter_parms['filter_fir']
157 157 filter.filter_2 = filter_parms['filter_2']
158 158 filter.filter_5 = filter_parms['filter_5']
159 159 filter.speed = filter_parms['speed']
160
160
161 161 kwargs = {}
162 162 kwargs['conf'] = conf
163 163 kwargs['filter'] = filter
164 164 kwargs['dev_conf'] = filter
165 165 kwargs['dev_conf_keys'] = ['name', 'clock',
166 166 'mult', 'fch', 'fch_decimal',
167 167 'filter_fir', 'filter_2',
168 168 'filter_5', 'speed']
169
169
170 170 kwargs['title'] = 'Filter View'
171 171 kwargs['suptitle'] = 'Details'
172 172 kwargs['button'] = 'SI'
173 173 kwargs['edit_button'] = 'Edit Filter'
174 174 kwargs['add_button'] = 'New Filter'
175
175
176 176 return render(request, 'jars_filter.html', kwargs)
177 177
178 178 def edit_filter(request, conf_id, filter_id):
179
179
180 180 conf = get_object_or_404(JARSConfiguration, pk=conf_id)
181 181 filter_parms = eval(conf.filter_parms)
182
182
183 183 if filter_id:
184 184 filter = get_object_or_404(JARSfilter, pk=filter_id)
185
185
186 186 if request.method=='GET':
187 187 form = JARSfilterForm(initial=filter_parms)
188
188
189 189 if request.method=='POST':
190 190 parms = {}
191 191 parms['name'] = request.POST['name']
192 192 parms['clock'] = request.POST['clock']
193 193 parms['mult'] = request.POST['mult']
194 194 parms['fch'] = request.POST['fch']
195 195 parms['fch_decimal'] = request.POST['fch_decimal']
196 196 parms['filter_fir'] = request.POST['filter_fir']
197 197 parms['filter_2'] = request.POST['filter_2']
198 198 parms['filter_5'] = request.POST['filter_5']
199 199 parms['speed'] = request.POST['speed']
200
200
201 201 conf.filter_parms = parms
202 202 conf.save()
203
203
204 204 #form = JARSfilterForm(request.POST)
205 205 #form = JARSfilterForm(request.POST, instance=filter)
206 206 #if form.is_valid():
207 207 #form.save()
208 208 # messages.success(request, 'JARS Filter successfully updated')
209 209 # return redirect('url_jars_filter', conf.id, filter.id)
210 210 return redirect('url_jars_filter', conf.id, filter.id)
211
211
212 212 kwargs = {}
213 213 kwargs['form'] = form
214 214 kwargs['title'] = conf.name
215 215 kwargs['suptitle'] = 'Edit Filter'
216 216 kwargs['button'] = 'Save'
217 217 # kwargs['previous'] = conf.get_absolute_url_edit()
218 218 kwargs['dev_conf'] = conf
219
219
220 220 return render(request, 'jars_filter_edit.html', kwargs)
221 221
222 222 def new_filter(request, conf_id):
223
223
224 224 conf = get_object_or_404(JARSConfiguration, pk=conf_id)
225
225
226 226 if request.method=='GET':
227 227 form = JARSfilterForm()
228
228
229 229 if request.method=='POST':
230 230 form = JARSfilterForm(request.POST)
231 231 if form.is_valid():
232 232 form.save()
233 233 new_filter = get_object_or_404(JARSfilter, name=request.POST['name'])
234 234 conf.filter = new_filter
235 235 conf.add_parms_to_filter()
236 236 messages.success(request, 'New JARS Filter successfully created')
237 237 return redirect('url_edit_jars_conf', id_conf=conf.id)
238
238
239 239 kwargs = {}
240 240 kwargs['form'] = form
241 241 kwargs['title'] = 'New Filter'
242 242 kwargs['suptitle'] = ''
243 243 kwargs['button'] = 'Create'
244 244 # kwargs['previous'] = conf.get_absolute_url_edit()
245 245 kwargs['dev_conf'] = conf
246
247 return render(request, 'jars_new_filter.html', kwargs) No newline at end of file
246
247 return render(request, 'jars_new_filter.html', kwargs)
General Comments 0
You need to be logged in to leave comments. Login now