def form_valid(self, form):
"""
If the dosing-regime is valid, then check if the formset is valid. If
it is, then continue saving.
"""
self.object = form.save(commit=False)
# unpack dose-groups into formset and validate
fs_initial = json.loads(self.request.POST['dose_groups_json'])
fs = forms.dosegroup_formset_factory(fs_initial, self.object.num_dose_groups)
if fs.is_valid():
self.object.save()
# instead of checking existing vs. new, just delete all old
# dose-groups, and save new formset
models.DoseGroup.objects.filter(dose_regime=self.object).delete()
# now save dose-groups, one for each dosing regime
for dose in fs.forms:
dose.instance.dose_regime = self.object
fs.save()
return super(DosingRegimeUpdate, self).form_valid(form)
else:
# invalid formset; extract formset errors
for f in fs.forms:
if len(f.errors.keys())>0:
self.dose_groups_errors = form_error_list_to_ul(f)
break
return self.form_invalid(form)
def post(self, request, *args, **kwargs):
#first, try to save endpoint
self.object = None
form_class = self.get_form_class()
form = self.get_form(form_class)
if form.is_valid():
endpoint_model = form.save(commit=False)
endpoint_model.individual_animal_data = True
endpoint_model.animal_group = self.parent
endpoint_model.save()
form.save_m2m()
self.object = endpoint_model
#now, try to save each endpoint-group
egs = json.loads(request.POST['egs_json'])
iads = json.loads(request.POST['iad_json'])
for i, eg in enumerate(egs):
eg['endpoint'] = endpoint_model.pk
eg_form = forms.EndpointGroupForm(eg)
if eg_form.is_valid():
eg_form.save()
iads_for_eg = [v for v in iads if v['dose_group_id'] == eg_form.instance.dose_group_id]
for iad in iads_for_eg:
iad['endpoint_group'] = eg_form.instance.pk
iad_form = forms.IndividualAnimalForm(iad)
if iad_form.is_valid():
iad_form.save()
else:
self.iad_errors = form_error_list_to_ul(iad_form)
self.object.delete()
return self.form_invalid(form)
else:
self.egs_errors = form_error_list_to_ul(eg_form)
self.object.delete()
return self.form_invalid(form)
else:
return self.form_invalid(form)
self.send_message() # replicate MessageMixin
return HttpResponseRedirect(self.get_success_url())
def form_valid(self, form):
"""
If an animal group is NOT generational, then it requires its own dosing
regime. Thus, we must make sure the dosing regime is valid before
attempting to save. If an animal group IS generational, a dosing-regime
can be specified from parent groups. OR, a dosing-regime can be created.
"""
self.object = form.save(commit=False)
# If a dosing-regime is already specified, save as normal
if self.is_generational and self.object.dosing_regime:
return super(AnimalGroupCreate, self).form_valid(form)
# Otherwise we create a new dosing-regime, as well as the associated
# dose-groups using a formset.
self.form_dosing_regime = forms.DosingRegimeForm(self.request.POST)
if self.form_dosing_regime.is_valid():
dosing_regime = self.form_dosing_regime.save(commit=False)
# unpack dose-groups into formset and validate
fs_initial = json.loads(self.request.POST['dose_groups_json'])
fs = forms.dosegroup_formset_factory(fs_initial, dosing_regime.num_dose_groups)
if fs.is_valid():
# save dosing-regime and associate animal-group,
# setting foreign-key interrelationships
dosing_regime.save()
self.object.dosing_regime = dosing_regime
self.object.save()
dosing_regime.dosed_animals = self.object
dosing_regime.save()
# now save dose-groups, one for each dosing regime
for dose in fs.forms:
dose.instance.dose_regime = dosing_regime
fs.save()
return super(AnimalGroupCreate, self).form_valid(form)
else:
# invalid formset; extract formset errors
for f in fs.forms:
if len(f.errors.keys())>0:
self.dose_groups_errors = form_error_list_to_ul(f)
break
return self.form_invalid(form)
else:
# invalid dosing-regime
return self.form_invalid(form)
def post(self, request, *args, **kwargs):
"""
First check if original model is valid. If so, then add to list of valid models.
Next, go through each EG, binding with instance if one exists. Go through
each and make sure each is valid, and if so, add to list. Then, if all
are valid, save each in list. Delete any EGs which greater than the list.
"""
valid_endpoint_forms = []
valid_iad_forms = []
self.object = self.get_object()
form_class = self.get_form_class()
form = self.get_form(form_class)
if form.is_valid():
#now, try to save each endpoint
egs = json.loads(request.POST['egs_json'])
iads = json.loads(request.POST['iad_json'])
for i, eg in enumerate(egs):
eg['endpoint'] = self.object.pk
try:
eg_form = forms.EndpointGroupForm(eg,
instance=models.EndpointGroup.objects.get(endpoint=self.object.pk, dose_group_id=i))
except:
eg_form = forms.EndpointGroupForm(eg)
if eg_form.is_valid():
valid_endpoint_forms.append(eg_form)
#check individual animal groups
iads_for_eg = [v for v in iads if v['dose_group_id'] == eg_form.instance.dose_group_id]
for iad in iads_for_eg:
iad['endpoint_group'] = eg_form.instance.pk
iad_form = forms.IndividualAnimalForm(iad)
if iad_form.is_valid():
valid_iad_forms.append(iad_form)
else:
self.iad_errors = form_error_list_to_ul(iad_form)
return self.form_invalid(form)
else:
self.egs_errors = form_error_list_to_ul(eg_form)
return self.form_invalid(form)
else:
return self.form_invalid(form)
#now, save each form, and delete any existing fields not found here
form.save()
valid_eg_pks = []
for form in valid_endpoint_forms:
valid_eg = form.save()
valid_eg_pks.append(valid_eg.pk)
models.EndpointGroup.objects\
.filter(endpoint=self.object.pk)\
.exclude(pk__in=valid_eg_pks).delete()
valid_iad_models = []
for form in valid_iad_forms:
valid_iad_models.append(form.save(commit=False))
# NOTE that this doesn't update existing objects, but creates entirely new
# ones. If update is required for auditing-logs, will need to pass the pk
# for each group-back and forth from model. TODO in future?
models.IndividualAnimal.objects.filter(endpoint_group__in=valid_eg_pks).delete()
models.IndividualAnimal.objects.bulk_create(valid_iad_models)
self.send_message() # replicate MessageMixin
return HttpResponseRedirect(self.get_success_url())
