def get_endpoints(self, request=None):
qs = Endpoint.objects.none()
filters = {"assessment_id": self.assessment_id}
if self.visual_type == self.BIOASSAY_AGGREGATION:
if request:
ids = request.POST.getlist('endpoints')
else:
ids = self.endpoints.values_list('id', flat=True)
filters["id__in"] = ids
qs = Endpoint.objects.filter(**filters)
elif self.visual_type == self.BIOASSAY_CROSSVIEW:
if request:
dose_id = tryParseInt(request.POST.get('dose_units'), -1)
Prefilter.setFiltersFromForm(filters, request.POST,
self.visual_type)
else:
dose_id = self.dose_units_id
Prefilter.setFiltersFromObj(filters, self.prefilters)
filters[
"animal_group__dosing_regime__doses__dose_units_id"] = dose_id
qs = Endpoint.objects.filter(**filters).distinct('id')
return qs
def get_endpoints(self, request=None):
qs = Endpoint.objects.none()
filters = {"assessment_id": self.assessment_id}
if self.visual_type == self.BIOASSAY_AGGREGATION:
if request:
ids = request.POST.getlist('endpoints')
else:
ids = self.endpoints.values_list('id', flat=True)
filters["id__in"] = ids
qs = Endpoint.objects.filter(**filters)
elif self.visual_type == self.BIOASSAY_CROSSVIEW:
if request:
dose_id = tryParseInt(request.POST.get('dose_units'), -1)
Prefilter.setFiltersFromForm(filters, request.POST, self.visual_type)
else:
dose_id = self.dose_units_id
Prefilter.setFiltersFromObj(filters, self.prefilters)
filters["animal_group__dosing_regime__doses__dose_units_id"] = dose_id
qs = Endpoint.objects.filter(**filters).distinct('id')
return qs
def clean(self):
super(BaseGroupResultFormset, self).clean()
# check that there is at least one result-group
count = len(filter(lambda f: f.is_valid() and f.clean(), self.forms))
if count < 1:
raise forms.ValidationError("At least one group is required.")
mfs = 0
for form in self.forms:
if form.cleaned_data['is_main_finding']:
mfs += 1
if mfs > 1:
raise forms.ValidationError("Only one-group can be the main-finding.")
if self.result:
comparison_set_id = self.result.comparison_set_id
else:
comparison_set_id = tryParseInt(self.data['comparison_set'], -1)
# Ensure all groups in group collection are accounted for,
# and no other groups exist
group_ids = [form.cleaned_data['group'].id for form in self.forms]
selectedGroups = models.Group.objects\
.filter(id__in=group_ids, comparison_set_id=comparison_set_id)
allGroups = models.Group.objects\
.filter(comparison_set_id=comparison_set_id)
if selectedGroups.count() != allGroups.count():
raise forms.ValidationError("Missing group(s) in this comparison set")
def get_queryset(self):
id_ = tryParseInt(self.request.GET.get('assessment_id'))
queryset = self.model.objects\
.filter(id=id_)\
.annotate(endpoint_count=Count('baseendpoint__endpoint'))\
.annotate(outcome_count=Count('baseendpoint__outcome'))\
.annotate(ivendpoint_count=Count('baseendpoint__ivendpoint'))
return queryset
def get_queryset(self):
id_ = tryParseInt(self.request.GET.get('assessment_id'))
queryset = self.model.objects\
.get_qs(id_)\
.annotate(endpoint_count=Count('baseendpoint__endpoint'))\
.annotate(outcome_count=Count('baseendpoint__outcome'))\
.annotate(ivendpoint_count=Count('baseendpoint__ivendpoint'))
return queryset
def get_assessment_from_query(request):
"""Returns assessment or None."""
assessment_id = tryParseInt(request.GET.get('assessment_id'))
if assessment_id is None:
raise RequiresAssessmentID
return models.Assessment.objects\
.get_qs(assessment_id)\
.first()
def create(self, request, *args, **kwargs):
# get an assessment
assessment_id = tryParseInt(request.data.get('assessment_id'), -1)
self.assessment = models.Assessment.objects\
.get_qs(assessment_id)\
.first()
if self.assessment is None:
raise RequiresAssessmentID
self.check_editing_permission(request)
return super().create(request, *args, **kwargs)
def update_reference_tags(self):
# find reference, check that the assessment is the same as the one we
# have permissions-checked for, and if so, update reference-tags
response = {"status": "fail"}
pk = tryParseInt(self.request.POST.get("pk"), -1)
ref = models.Reference.objects.filter(pk=pk, assessment=self.assessment).first()
if ref:
tag_pks = self.request.POST.getlist("tags[]", [])
ref.tags.set(tag_pks)
ref.last_updated = datetime.now()
ref.save()
response["status"] = "success"
return response
def get_form_kwargs(self):
kwargs = super().get_form_kwargs()
# check if we have a template to use
pk = tryParseInt(self.request.GET.get('initial'), -1)
if pk > 0:
obj = self.model.objects.filter(pk=pk).first()
permitted_assesments = Assessment.objects.get_viewable_assessments(
self.request.user, exclusion_id=self.assessment.pk)
if obj and obj.assessment in permitted_assesments:
kwargs['initial'] = model_to_dict(obj)
return kwargs
def get_form_kwargs(self):
kwargs = super().get_form_kwargs()
# check if we have a template to use
pk = tryParseInt(self.request.GET.get('initial'), -1)
if pk > 0:
obj = self.model.objects.filter(pk=pk).first()
permitted_assesments = Assessment.objects.get_viewable_assessments(
self.request.user, exclusion_id=self.assessment.pk)
if obj and obj.assessment in permitted_assesments:
kwargs['initial'] = model_to_dict(obj)
return kwargs
def update_reference_tags(self):
# find reference, check that the assessment is the same as the one we
# have permissions-checked for, and if so, update reference-tags
response = {"status": "fail"}
pk = tryParseInt(self.request.POST.get('pk'), -1)
ref = models.Reference.objects\
.filter(pk=pk, assessment=self.assessment).first()
if ref:
tag_pks = self.request.POST.getlist('tags[]', [])
ref.tags.set(tag_pks)
ref.last_updated = datetime.now()
ref.save()
response["status"] = "success"
return response
def has_permission(self, request, view):
if view.action in self.list_actions:
assessment_id = tryParseInt(request.GET.get('assessment_id'))
if assessment_id is None:
raise RequiresAssessmentID
view.assessment = models.Assessment.objects\
.filter(id=assessment_id)\
.first()
if view.assessment is None:
return False
return view.assessment.user_can_view_object(request.user)
return True
def setMaximumPercentControlChange(ep):
"""
For each endpoint, return the maximum absolute-change percent control
for that endpoint, or 0 if it cannot be calculated. Useful for
ordering data-pivot results.
"""
val = 0
changes = [
g['percentControlMean'] for g in ep['groups']
if tryParseInt(g['percentControlMean'], default=False)
]
if len(changes) > 0:
min_ = min(changes)
max_ = max(changes)
val = min_ if abs(min_) > abs(max_) else max_
ep['percentControlMaxChange'] = val
def setMaximumPercentControlChange(cls, ep):
"""
For each endpoint, return the maximum absolute-change percent control
for that endpoint, or 0 if it cannot be calculated. Useful for
ordering data-pivot results.
"""
val = 0
changes = [
g['percentControlMean']
for g in ep['groups']
if tryParseInt(g['percentControlMean'], default=False)
]
if len(changes) > 0:
min_ = min(changes)
max_ = max(changes)
val = min_ if abs(min_) > abs(max_) else max_
ep['percentControlMaxChange'] = val
def rob_filter(self, request):
params = self.request.query_params
assessment_id = tryParseInt(params.get('assessment_id'), -1)
query = Q(assessment_id=assessment_id)
effects = params.get('effect[]')
if effects:
query &= Q(effect__in=effects.split(','))
study_ids = params.get('study_id[]')
if study_ids:
query &= Q(animal_group__experiment__study__in=study_ids.split(','))
qs = models.Endpoint.objects.filter(query)
if qs.count() > 100:
raise NotAcceptable("Must contain < 100 endpoints")
serializer = self.get_serializer(qs, many=True)
return Response(serializer.data)
def rob_filter(self, request):
params = self.request.query_params
assessment_id = tryParseInt(params.get('assessment_id'), -1)
query = Q(assessment_id=assessment_id)
effects = params.get('effect[]')
if effects:
query &= Q(effect__in=effects.split(','))
study_ids = params.get('study_id[]')
if study_ids:
query &= Q(animal_group__experiment__study__in=study_ids.split(','))
qs = models.Endpoint.objects.filter(query)
if qs.count() > 100:
raise NotAcceptable("Must contain < 100 endpoints")
serializer = self.get_serializer(qs, many=True)
return Response(serializer.data)
def post_update_ReferenceFilterTag(self, response):
pk = tryParseInt(self.request.POST.get("pk"), -1)
try:
status = self.request.POST.get("status")
if status == "add":
parent_pk = self.request.POST.get("parent_pk", None)
name = self.request.POST.get("name")
response["node"] = models.ReferenceFilterTag.add_tag(self.assessment.pk, name, parent_pk)
elif status == "remove":
models.ReferenceFilterTag.remove_tag(self.assessment.pk, pk)
elif status == "move":
tag = get_object_or_404(models.ReferenceFilterTag, pk=pk)
offset = int(self.request.POST.get("offset"))
tag.move_within_parent(self.assessment.pk, offset)
elif status == "rename":
tag = get_object_or_404(models.ReferenceFilterTag, pk=pk)
assert tag.id in models.ReferenceFilterTag.get_descendants_pks(self.object.id)
tag.rename(self.request.POST.get("name"))
else:
raise Exception()
except:
response["status"] = "fail"
return response
def clean(self):
super().clean()
# check that there is at least one result-group
count = len([f for f in self.forms if f.is_valid() and f.clean()])
if count < 1:
raise forms.ValidationError("At least one group is required.")
mfs = 0
for form in self.forms:
if form.cleaned_data['is_main_finding']:
mfs += 1
if mfs > 1:
raise forms.ValidationError(
"Only one-group can be the main-finding.")
if self.result:
comparison_set_id = self.result.comparison_set_id
else:
comparison_set_id = tryParseInt(self.data['comparison_set'], -1)
# exit early if any individual form is invalid
if any([not form.is_valid() for form in self.forms]):
return
# Ensure all groups in group collection are accounted for,
# and no other groups exist
group_ids = [form.cleaned_data['group'].id for form in self.forms]
selectedGroups = models.Group.objects\
.filter(id__in=group_ids, comparison_set_id=comparison_set_id)
allGroups = models.Group.objects\
.filter(comparison_set_id=comparison_set_id)
if selectedGroups.count() != allGroups.count():
raise forms.ValidationError(
"Missing group(s) in this comparison set")
def rob_scores(self, request):
assessment_id = tryParseInt(self.request.query_params.get('assessment_id'), -1)
scores = self.model.objects.rob_scores(assessment_id)
return Response(scores)
def rob_scores(self, request):
assessment_id = tryParseInt(
self.request.query_params.get('assessment_id'), -1)
scores = self.model.objects.rob_scores(assessment_id)
return Response(scores)
def get_object(self, **kwargs):
pk = tryParseInt(self.request.GET.get('pk'), -1)
obj = get_object_or_404(self.model, pk=pk)
return super().get_object(object=obj)
def effects(self, request):
assessment_id = tryParseInt(
self.request.query_params.get('assessment_id'), -1)
effects = models.Endpoint.objects.get_effects(assessment_id)
return Response(effects)
def get_query(self, request, term):
id_ = tryParseInt(request.GET.get('related'), -1)
return self.model.objects.filter(
protocol__study__assessment_id=id_,
exposure_name__icontains=term)
def get_object(self, **kwargs):
pk = tryParseInt(self.request.GET.get('pk'), -1)
obj = get_object_or_404(self.model, pk=pk)
return super().get_object(object=obj)
def effects(self, request):
assessment_id = tryParseInt(self.request.query_params.get('assessment_id'), -1)
effects = models.Endpoint.get_effects(assessment_id)
return Response(effects)
def get_object(self, **kwargs):
pk = tryParseInt(self.request.GET.get("pk"), -1)
obj = get_object_or_404(self.model, pk=pk)
return super(TagsJSON, self).get_object(object=obj)
