def get_editing_dataset(self, request):
# Generate a pseudo-return when editing or creating a dataset.
# Do not include the settings field; this will be set from the
# input-form. Should approximately mirror the Visual API from rest-framework.
dose_units = None
try:
dose_units = int(request.POST.get("dose_units"))
except (TypeError, ValueError) as e:
# TypeError if dose_units is None; ValueError if dose_units is ""
pass
data = {
"title": request.POST.get("title"),
"slug": request.POST.get("slug"),
"caption": request.POST.get("caption"),
"dose_units": dose_units,
"created": datetime.now().isoformat(),
"last_updated": datetime.now().isoformat()
}
data["endpoints"] = [
SerializerHelper.get_serialized(e, json=False)
for e in self.get_endpoints(request)
]
data["studies"] = [
SerializerHelper.get_serialized(s, json=False)
for s in self.get_studies(request)
]
return json.dumps(data)
def get_editing_dataset(self, request):
# Generate a pseudo-return when editing or creating a dataset.
# Do not include the settings field; this will be set from the
# input-form. Should approximately mirror the Visual API from rest-framework.
dose_units = None
try:
dose_units = int(request.POST.get("dose_units"))
except (TypeError, ValueError) as e:
# TypeError if dose_units is None; ValueError if dose_units is ""
pass
data = {
"title": request.POST.get("title"),
"slug": request.POST.get("slug"),
"caption": request.POST.get("caption"),
"dose_units": dose_units,
"created": datetime.now().isoformat(),
"last_updated": datetime.now().isoformat()
}
data["endpoints"] = [
SerializerHelper.get_serialized(e, json=False)
for e in self.get_endpoints(request)
]
data["studies"] = [
SerializerHelper.get_serialized(s, json=False)
for s in self.get_studies(request)
]
return json.dumps(data)
def get_docx_template_context(assessment, queryset):
"""
Given a queryset of endpoints, invert the cached results to build
a top-down data hierarchy from study to endpoint. We use this
approach since our endpoints are cached, so while it may require
more computation, its close to free on database access.
"""
endpoints = [
SerializerHelper.get_serialized(obj, json=False)
for obj in queryset
]
studies = {}
# flip dictionary nesting
for thisEp in endpoints:
thisAG = thisEp["animal_group"]
thisExp = thisEp["animal_group"]["experiment"]
thisStudy = thisEp["animal_group"]["experiment"]["study"]
study = studies.get(thisStudy["id"])
if study is None:
study = thisStudy
study["exps"] = {}
studies[study["id"]] = study
exp = study["exps"].get(thisExp["id"])
if exp is None:
exp = thisExp
exp["ags"] = {}
study["exps"][exp["id"]] = exp
ag = exp["ags"].get(thisAG["id"])
if ag is None:
ag = thisAG
ag["eps"] = {}
exp["ags"][ag["id"]] = ag
ep = ag["eps"].get(thisEp["id"])
if ep is None:
ep = thisEp
ag["eps"][ep["id"]] = ep
# convert value dictionaries to lists
studies = sorted(list(studies.values()),
key=lambda obj: (obj["short_citation"].lower()))
for study in studies:
study["exps"] = sorted(list(study["exps"].values()),
key=lambda obj: (obj["name"].lower()))
for exp in study["exps"]:
exp["ags"] = sorted(list(exp["ags"].values()),
key=lambda obj: (obj["name"].lower()))
for ag in exp["ags"]:
ag["eps"] = sorted(list(ag["eps"].values()),
key=lambda obj: (obj["name"].lower()))
return {
"assessment": AssessmentSerializer().to_representation(assessment),
"studies": studies
}
def to_representation(self, instance):
ret = super().to_representation(instance)
ret['url_update'] = instance.get_update_url()
ret['url_delete'] = instance.get_delete_url()
ret["endpoints"] = [
SerializerHelper.get_serialized(d, json=False)
for d in instance.get_endpoints()
]
ret["studies"] = [
SerializerHelper.get_serialized(d, json=False)
for d in instance.get_studies()
]
return ret
def to_representation(self, instance):
ret = super().to_representation(instance)
ret['url_update'] = instance.get_update_url()
ret['url_delete'] = instance.get_delete_url()
ret["endpoints"] = [
SerializerHelper.get_serialized(d, json=False)
for d in instance.get_endpoints()
]
ret["studies"] = [
SerializerHelper.get_serialized(d, json=False)
for d in instance.get_studies()
]
return ret
def invalidate_caches_study(sender, instance, **kwargs):
Model = None
filters = {}
if instance.study_type == 0:
Model = get_model('animal', 'Endpoint')
filters["animal_group__experiment__study"] = instance.id
elif instance.study_type == 1:
Model = get_model('epi', 'AssessedOutcome')
filters["exposure__study_population__study"] = instance.id
elif instance.study_type == 4:
Model = get_model('epi', 'MetaResult')
filters["protocol__study"] = instance.id
Study.delete_caches([instance.id])
if Model:
ids = Model.objects.filter(**filters).values_list('id', flat=True)
SerializerHelper.delete_caches(Model, ids)
def invalidate_caches_study(sender, instance, **kwargs):
Model = None
filters = {}
if instance.study_type == 0:
Model = get_model("animal", "Endpoint")
filters["animal_group__experiment__study"] = instance.id
elif instance.study_type == 1:
Model = get_model("epi", "AssessedOutcome")
filters["exposure__study_population__study"] = instance.id
elif instance.study_type == 4:
Model = get_model("epi", "MetaResult")
filters["protocol__study"] = instance.id
Study.delete_caches([instance.id])
if Model:
ids = Model.objects.filter(**filters).values_list("id", flat=True)
SerializerHelper.delete_caches(Model, ids)
def get_docx_template_context(cls, assessment, queryset):
studies = [
SerializerHelper.get_serialized(study, json=False)
for study in queryset
]
return {
"assessment": AssessmentSerializer().to_representation(assessment),
"studies": studies
}
def invalidate_caches_study(sender, instance, **kwargs):
Model = None
filters = {}
if instance.study_type == 0:
Model = apps.get_model('animal', 'Endpoint')
filters["animal_group__experiment__study"] = instance.id
elif instance.study_type == 1:
Model = apps.get_model('epi', 'Outcome')
filters["study_population__study"] = instance.id
elif instance.study_type == 2:
Model = apps.get_model('invitro', 'ivendpoint')
filters["experiment__study_id"] = instance.id
elif instance.study_type == 4:
Model = apps.get_model('epimeta', 'MetaResult')
filters["protocol__study"] = instance.id
models.Study.delete_caches([instance.id])
if Model:
ids = Model.objects\
.filter(**filters)\
.values_list('id', flat=True)
SerializerHelper.delete_caches(Model, ids)
url = serializers.CharField(source='get_absolute_url', read_only=True)
results = ResultSerializer(many=True)
comparison_sets = ComparisonSetLinkSerializer(many=True)
class Meta:
model = models.Outcome
fields = '__all__'
class ComparisonSetSerializer(serializers.ModelSerializer):
url = serializers.CharField(source='get_absolute_url', read_only=True)
exposure = ExposureSerializer()
outcome = OutcomeSerializer()
study_population = StudyPopulationSerializer()
groups = GroupSerializer(many=True)
class Meta:
model = models.ComparisonSet
fields = '__all__'
class OutcomeCleanupFieldsSerializer(DynamicFieldsMixin,
serializers.ModelSerializer):
class Meta:
model = models.Outcome
cleanup_fields = model.TEXT_CLEANUP_FIELDS
fields = cleanup_fields + ('id', )
SerializerHelper.add_serializer(models.Outcome, OutcomeSerializer)
def clear_cache(Model, filters):
ids = Model.objects\
.filter(**filters)\
.values_list('id', flat=True)
SerializerHelper.delete_caches(Model, ids)
can_create_sets = serializers.BooleanField(read_only=True)
effects = EffectTagsSerializer()
diagnostic = serializers.CharField(source='get_diagnostic_display', read_only=True)
url = serializers.CharField(source='get_absolute_url', read_only=True)
results = ResultSerializer(many=True)
comparison_sets = ComparisonSetLinkSerializer(many=True)
class Meta:
model = models.Outcome
class ComparisonSetSerializer(serializers.ModelSerializer):
url = serializers.CharField(source='get_absolute_url', read_only=True)
exposure = ExposureSerializer()
outcome = OutcomeSerializer()
study_population = StudyPopulationSerializer()
groups = GroupSerializer(many=True)
class Meta:
model = models.ComparisonSet
class OutcomeCleanupFieldsSerializer(DynamicFieldsMixin, serializers.ModelSerializer):
class Meta:
model = models.Outcome
cleanup_fields = model.TEXT_CLEANUP_FIELDS
fields = cleanup_fields + ('id', )
SerializerHelper.add_serializer(models.Outcome, OutcomeSerializer)
study = StudySerializer()
inclusion_criteria = serializers.StringRelatedField(many=True)
exclusion_criteria = serializers.StringRelatedField(many=True)
url = serializers.ReadOnlyField(source="get_absolute_url")
protocol_type = serializers.ReadOnlyField(source="get_protocol_type_display")
lit_search_strategy = serializers.ReadOnlyField(source="get_lit_search_strategy_display")
results = MetaResultLinkSerializer(many=True)
class Meta:
model = models.MetaProtocol
class MetaResultSerializer(serializers.ModelSerializer):
protocol = MetaProtocolSerializer()
url = serializers.ReadOnlyField(source="get_absolute_url")
metric = ResultMetricSerializer()
adjustment_factors = serializers.StringRelatedField(many=True)
single_results = SingleResultSerializer(many=True)
def to_representation(self, instance):
ret = super(MetaResultSerializer, self).to_representation(instance)
ret['estimateFormatted'] = instance.estimate_formatted
return ret
class Meta:
model = models.MetaResult
SerializerHelper.add_serializer(models.MetaProtocol, MetaProtocolSerializer)
SerializerHelper.add_serializer(models.MetaResult, MetaResultSerializer)
class FinalRobStudySerializer(StudySerializer):
assessment = serializers.PrimaryKeyRelatedField(read_only=True)
riskofbiases = RiskOfBiasSerializer(many=True, read_only=True)
class Meta:
model = models.Study
exclude = (
'searches',
'identifiers',
)
def to_representation(self, instance):
instance.riskofbiases = instance.riskofbiases.filter(final=True)
ret = super().to_representation(instance)
return ret
class StudyCleanupFieldsSerializer(DynamicFieldsMixin,
serializers.ModelSerializer):
class Meta:
model = models.Study
cleanup_fields = model.TEXT_CLEANUP_FIELDS
fields = (
'id',
'short_citation',
) + cleanup_fields
SerializerHelper.add_serializer(models.Study, VerboseStudySerializer)
def get_json(self, json_encode=True):
return SerializerHelper.get_serialized(self, json=json_encode, from_cache=False)
def get_docx_template_context(assessment, queryset):
"""
Given a queryset of meta-results, invert the cached results to build
a top-down data hierarchy from study to meta-result. We use this
approach since our meta-results are cached, so while it may require
more computation, its close to free on database access.
"""
def getStatMethods(mr):
key = "{}|{}".format(
mr["adjustments_list"],
mr["statistical_notes"]
)
return key, mr
results = [
SerializerHelper.get_serialized(obj, json=False)
for obj in queryset
]
studies = {}
# flip dictionary nesting
for thisMr in results:
thisPro = thisMr["protocol"]
thisStudy = thisMr["protocol"]["study"]
study = studies.get(thisStudy["id"])
if study is None:
study = thisStudy
study["protocols"] = {}
studies[study["id"]] = study
pro = study["protocols"].get(thisPro["id"])
if pro is None:
pro = thisPro
pro["inclusion_list"] = ', '.join(pro["inclusion_criteria"])
pro["exclusion_list"] = ', '.join(pro["exclusion_criteria"])
pro["results"] = {}
pro["statistical_methods"] = {}
study["protocols"][pro["id"]] = pro
mr = pro["results"].get(thisMr["id"])
if mr is None:
mr = thisMr
mr["ci_percent"] = int(mr["ci_units"] * 100.)
mr["adjustments_list"] = ', '.join(
sorted(mr["adjustment_factors"]))
pro["results"][mr["id"]] = mr
statKey, statVal = getStatMethods(thisMr)
stats = pro["statistical_methods"].get(statKey)
if stats is None:
stats = statVal
pro["statistical_methods"][statKey] = statVal
stats["sm_endpoints"] = []
stats["sm_endpoints"].append(thisMr)
# convert value dictionaries to lists
studies = sorted(
list(studies.values()),
key=lambda obj: (obj["short_citation"].lower()))
for study in studies:
study["protocols"] = sorted(
list(study["protocols"].values()),
key=lambda obj: (obj["name"].lower()))
for pro in study["protocols"]:
pro["results"] = sorted(
list(pro["results"].values()),
key=lambda obj: (obj["label"].lower()))
pro["statistical_methods"] = list(pro["statistical_methods"].values())
for obj in pro["statistical_methods"]:
obj["sm_endpoints"] = "; ".join([
d["label"] for d in obj["sm_endpoints"]
])
return {
"assessment": AssessmentSerializer().to_representation(assessment),
"studies": studies
}
def d_response(self, json_encode=True):
return SerializerHelper.get_serialized(self, json=json_encode)
models.EndpointGroup.percentControl(ret['data_type'], ret['endpoint_group'])
# get individual animal data
if instance.individual_animal_data:
models.EndpointGroup.getIndividuals(instance, ret['endpoint_group'])
# get BMD
ret['BMD'] = None
try:
model = instance.BMD_session.latest().selected_model
if model is not None:
ret['BMD'] = BMDModelRunSerializer().to_representation(model)
except instance.BMD_session.model.DoesNotExist:
pass
return ret
class Meta:
model = models.Endpoint
class AggregationSerializer(serializers.ModelSerializer):
endpoints = EndpointSerializer(many=True)
class Meta:
model = models.Aggregation
SerializerHelper.add_serializer(models.Endpoint, EndpointSerializer)
SerializerHelper.add_serializer(models.Aggregation, AggregationSerializer)
from rest_framework import serializers
from utils.helper import SerializerHelper
from . import models
class HAWCUserSerializer(serializers.ModelSerializer):
full_name = serializers.CharField(source='get_full_name')
class Meta:
model = models.HAWCUser
fields = (
'id',
'full_name',
)
SerializerHelper.add_serializer(models.HAWCUser, HAWCUserSerializer)
class Meta:
model = models.RiskOfBiasScore
fields = ('id', 'score', 'notes', 'metric')
class RiskOfBiasSerializer(serializers.ModelSerializer):
scores = RiskOfBiasScoreSerializer(read_only=False, many=True, partial=True)
author = HAWCUserSerializer(read_only=True)
class Meta:
model = models.RiskOfBias
fields = ('id', 'author', 'active',
'final', 'study', 'created',
'last_updated', 'scores')
def update(self, instance, validated_data):
"""
Updates the nested RiskOfBiasScores with submitted data before updating
the RiskOfBias instance.
"""
score_data = validated_data.pop('scores')
for score, form_data in zip(instance.scores.all(), score_data):
for field, value in form_data.items():
setattr(score, field, value)
score.save()
return super(RiskOfBiasSerializer, self).update(instance, validated_data)
SerializerHelper.add_serializer(models.RiskOfBias, RiskOfBiasSerializer)
class Meta:
model = models.StudyQuality
exclude = ('object_id', 'content_type')
class StudySerializer(serializers.ModelSerializer):
def to_representation(self, instance):
ret = super(StudySerializer, self).to_representation(instance)
ret['study_type'] = instance.get_study_type_display()
ret['coi_reported'] = instance.get_coi_reported_display()
ret['url'] = instance.get_absolute_url()
return ret
class Meta:
model = models.Study
class VerboseStudySerializer(StudySerializer):
assessment = serializers.PrimaryKeyRelatedField(read_only=True)
searches = serializers.PrimaryKeyRelatedField(many=True, read_only=True)
qualities = StudyQualitySerializer(many=True, read_only=True)
identifiers = IdentifiersSerializer(many=True)
tags = ReferenceTagsSerializer()
class Meta:
model = models.Study
SerializerHelper.add_serializer(models.Study, VerboseStudySerializer)
ret = super(MetaProtocolSerializer, self).to_representation(instance)
ret['url'] = instance.get_absolute_url()
ret['protocol_type'] = instance.get_protocol_type_display()
ret['lit_search_strategy'] = instance.get_lit_search_strategy_display()
return ret
class Meta:
model = models.MetaProtocol
class MetaResultSerializer(serializers.ModelSerializer):
protocol = MetaProtocolSerializer()
statistical_metric = StatisticalMetricSerializer()
single_results = SingleResultSerializer(many=True)
adjustment_factors = serializers.StringRelatedField(many=True)
def to_representation(self, instance):
ret = super(MetaResultSerializer, self).to_representation(instance)
ret['url'] = instance.get_absolute_url()
ret['estimateFormatted'] = instance.estimate_formatted
return ret
class Meta:
model = models.MetaResult
SerializerHelper.add_serializer(models.StudyPopulation, StudyPopulationSerializer)
SerializerHelper.add_serializer(models.AssessedOutcome, AssessedOutcomeSerializer)
SerializerHelper.add_serializer(models.MetaProtocol, MetaProtocolSerializer)
SerializerHelper.add_serializer(models.MetaResult, MetaResultSerializer)
protocol_type = serializers.ReadOnlyField(
source="get_protocol_type_display")
lit_search_strategy = serializers.ReadOnlyField(
source="get_lit_search_strategy_display")
results = MetaResultLinkSerializer(many=True)
class Meta:
model = models.MetaProtocol
fields = '__all__'
class MetaResultSerializer(serializers.ModelSerializer):
protocol = MetaProtocolSerializer()
url = serializers.ReadOnlyField(source="get_absolute_url")
metric = ResultMetricSerializer()
adjustment_factors = serializers.StringRelatedField(many=True)
single_results = SingleResultSerializer(many=True)
def to_representation(self, instance):
ret = super().to_representation(instance)
ret['estimateFormatted'] = instance.estimate_formatted
return ret
class Meta:
model = models.MetaResult
fields = '__all__'
SerializerHelper.add_serializer(models.MetaProtocol, MetaProtocolSerializer)
SerializerHelper.add_serializer(models.MetaResult, MetaResultSerializer)
study = StudyAssessmentSerializer(read_only=True)
type_display = serializers.CharField(source='get_type_display')
status_display = serializers.CharField(source='get_status_display')
class Meta:
model = models.Task
fields = '__all__'
read_only_fields = (
'id',
'study',
'open',
'started',
'completed',
)
def update(self, instance, validated_data):
if self.initial_data['owner']:
owner_id = self.initial_data['owner']['id']
instance.owner = HAWCUser.objects.get(pk=owner_id)
instance.save()
return super().update(instance, validated_data)
class TaskByAssessmentSerializer(TaskSerializer):
study = StudyAssessmentSerializer(read_only=True)
class Meta(TaskSerializer.Meta):
depth = 2
SerializerHelper.add_serializer(models.Task, TaskSerializer)
def get_docx_template_context(assessment, queryset):
studies = [SerializerHelper.get_serialized(study, json=False) for study in queryset]
return {
"assessment": AssessmentSerializer().to_representation(assessment),
"studies": studies
}
ret["settings"] = settings
return ret
class Meta:
model = models.Visual
exclude = ('endpoints', )
class VisualSerializer(CollectionVisualSerializer):
def to_representation(self, instance):
ret = super().to_representation(instance)
ret['url_update'] = instance.get_update_url()
ret['url_delete'] = instance.get_delete_url()
ret["endpoints"] = [
SerializerHelper.get_serialized(d, json=False)
for d in instance.get_endpoints()
]
ret["studies"] = [
SerializerHelper.get_serialized(d, json=False)
for d in instance.get_studies()
]
return ret
SerializerHelper.add_serializer(models.Visual, VisualSerializer)
def clear_cache(Model, filters):
ids = Model.objects\
.filter(**filters)\
.values_list('id', flat=True)
SerializerHelper.delete_caches(Model, ids)
def get_docx_template_context(cls, assessment, queryset):
"""
Given a queryset of endpoints, invert the cached results to build
a top-down data hierarchy from study to endpoint. We use this
approach since our endpoints are cached, so while it may require
more computation, its close to free on database access.
"""
endpoints = [
SerializerHelper.get_serialized(obj, json=False)
for obj in queryset
]
studies = {}
# flip dictionary nesting
for thisEp in endpoints:
thisAG = thisEp["animal_group"]
thisExp = thisEp["animal_group"]["experiment"]
thisStudy = thisEp["animal_group"]["experiment"]["study"]
study = studies.get(thisStudy["id"])
if study is None:
study = thisStudy
study["exps"] = {}
studies[study["id"]] = study
exp = study["exps"].get(thisExp["id"])
if exp is None:
exp = thisExp
exp["ags"] = {}
study["exps"][exp["id"]] = exp
ag = exp["ags"].get(thisAG["id"])
if ag is None:
ag = thisAG
ag["eps"] = {}
exp["ags"][ag["id"]] = ag
ep = ag["eps"].get(thisEp["id"])
if ep is None:
ep = thisEp
ag["eps"][ep["id"]] = ep
# convert value dictionaries to lists
studies = sorted(
studies.values(),
key=lambda obj: (obj["short_citation"].lower()))
for study in studies:
study["exps"] = sorted(
study["exps"].values(),
key=lambda obj: (obj["name"].lower()))
for exp in study["exps"]:
exp["ags"] = sorted(
exp["ags"].values(),
key=lambda obj: (obj["name"].lower()))
for ag in exp["ags"]:
ag["eps"] = sorted(
ag["eps"].values(),
key=lambda obj: (obj["name"].lower()))
return {
"assessment": AssessmentSerializer().to_representation(assessment),
"studies": studies
}
endpoints = MiniIVEndpointSerializer(many=True)
class IVEndpointCleanupFieldsSerializer(DynamicFieldsMixin,
serializers.ModelSerializer):
study_short_citation = serializers.SerializerMethodField()
class Meta:
model = models.IVEndpoint
cleanup_fields = ('study_short_citation', ) + model.TEXT_CLEANUP_FIELDS
fields = cleanup_fields + ('id', )
def get_study_short_citation(self, obj):
return obj.experiment.study.short_citation
class IVChemicalCleanupFieldsSerializer(DynamicFieldsMixin,
serializers.ModelSerializer):
study_short_citation = serializers.SerializerMethodField()
class Meta:
model = models.IVChemical
cleanup_fields = ('study_short_citation', ) + model.TEXT_CLEANUP_FIELDS
fields = cleanup_fields + ('id', )
def get_study_short_citation(self, obj):
return obj.study.short_citation
SerializerHelper.add_serializer(models.IVEndpoint, IVEndpointSerializer)
def get_json(self, json_encode=True):
return SerializerHelper.get_serialized(self, json=json_encode)
def delete_caches(cls, ids):
SerializerHelper.delete_caches(cls, ids)
settings = {}
ret["settings"] = settings
return ret
class Meta:
model = models.Visual
exclude = ('endpoints', )
class VisualSerializer(CollectionVisualSerializer):
def to_representation(self, instance):
ret = super().to_representation(instance)
ret['url_update'] = instance.get_update_url()
ret['url_delete'] = instance.get_delete_url()
ret["endpoints"] = [
SerializerHelper.get_serialized(d, json=False)
for d in instance.get_endpoints()
]
ret["studies"] = [
SerializerHelper.get_serialized(d, json=False)
for d in instance.get_studies()
]
return ret
SerializerHelper.add_serializer(models.Visual, VisualSerializer)
def d_response(self, json_encode=True):
return SerializerHelper.get_serialized(self, json=json_encode)
from rest_framework import serializers
from utils.helper import SerializerHelper
from . import models
class HAWCUserSerializer(serializers.ModelSerializer):
full_name = serializers.CharField(source='get_full_name')
class Meta:
model = models.HAWCUser
fields = ('id', 'full_name', )
SerializerHelper.add_serializer(models.HAWCUser, HAWCUserSerializer)
experiment = serializers.PrimaryKeyRelatedField(read_only=True)
chemical = _IVChemicalSerializer()
groups = serializers.PrimaryKeyRelatedField(read_only=True, many=True)
benchmarks = serializers.PrimaryKeyRelatedField(read_only=True, many=True)
category = serializers.PrimaryKeyRelatedField(read_only=True)
def to_representation(self, instance):
ret = super(MiniIVEndpointSerializer, self).to_representation(instance)
ret['url'] = instance.get_absolute_url()
return ret
class Meta:
model = models.IVEndpoint
class IVExperimentSerializerFull(IVExperimentSerializer):
url_update = serializers.CharField(source='get_update_url', read_only=True)
url_delete = serializers.CharField(source='get_delete_url', read_only=True)
url_create_endpoint = serializers.CharField(source='get_endpoint_create_url', read_only=True)
endpoints = MiniIVEndpointSerializer(many=True)
class CleanupFieldsSerializer(DynamicFieldsMixin, serializers.ModelSerializer):
class Meta:
model = models.IVEndpoint
cleanup_fields = model.text_cleanup_fields()
fields = cleanup_fields + ('id', 'name')
SerializerHelper.add_serializer(models.IVEndpoint, IVEndpointSerializer)
def get_docx_template_context(assessment, queryset):
"""
Given a queryset of meta-results, invert the cached results to build
a top-down data hierarchy from study to meta-result. We use this
approach since our meta-results are cached, so while it may require
more computation, its close to free on database access.
"""
def getStatMethods(mr):
key = "{}|{}".format(
mr["adjustments_list"],
mr["statistical_notes"]
)
return key, mr
results = [
SerializerHelper.get_serialized(obj, json=False)
for obj in queryset
]
studies = {}
# flip dictionary nesting
for thisMr in results:
thisPro = thisMr["protocol"]
thisStudy = thisMr["protocol"]["study"]
study = studies.get(thisStudy["id"])
if study is None:
study = thisStudy
study["protocols"] = {}
studies[study["id"]] = study
pro = study["protocols"].get(thisPro["id"])
if pro is None:
pro = thisPro
pro["inclusion_list"] = ', '.join(pro["inclusion_criteria"])
pro["exclusion_list"] = ', '.join(pro["exclusion_criteria"])
pro["results"] = {}
pro["statistical_methods"] = {}
study["protocols"][pro["id"]] = pro
mr = pro["results"].get(thisMr["id"])
if mr is None:
mr = thisMr
mr["ci_percent"] = int(mr["ci_units"] * 100.)
mr["adjustments_list"] = ', '.join(
sorted(mr["adjustment_factors"]))
pro["results"][mr["id"]] = mr
statKey, statVal = getStatMethods(thisMr)
stats = pro["statistical_methods"].get(statKey)
if stats is None:
stats = statVal
pro["statistical_methods"][statKey] = statVal
stats["sm_endpoints"] = []
stats["sm_endpoints"].append(thisMr)
# convert value dictionaries to lists
studies = sorted(
list(studies.values()),
key=lambda obj: (obj["short_citation"].lower()))
for study in studies:
study["protocols"] = sorted(
list(study["protocols"].values()),
key=lambda obj: (obj["name"].lower()))
for pro in study["protocols"]:
pro["results"] = sorted(
list(pro["results"].values()),
key=lambda obj: (obj["label"].lower()))
pro["statistical_methods"] = list(pro["statistical_methods"].values())
for obj in pro["statistical_methods"]:
obj["sm_endpoints"] = "; ".join([
d["label"] for d in obj["sm_endpoints"]
])
return {
"assessment": AssessmentSerializer().to_representation(assessment),
"studies": studies
}
def delete_caches(cls, ids):
SerializerHelper.delete_caches(cls, ids)
def get_json(self, json_encode=True):
return SerializerHelper.get_serialized(self, json=json_encode, from_cache=False)
def get_json(self, json_encode=True):
return SerializerHelper.get_serialized(self, json=json_encode)
"""
score_data = validated_data.pop('scores')
for score, form_data in zip(instance.scores.all(), score_data):
for field, value in list(form_data.items()):
setattr(score, field, value)
score.save()
return super().update(instance, validated_data)
class AssessmentMetricScoreSerializer(serializers.ModelSerializer):
scores = serializers.SerializerMethodField('get_final_score')
class Meta:
model = models.RiskOfBiasMetric
fields = ('id', 'name', 'description', 'scores')
def get_final_score(self, instance):
scores = instance.scores.filter(riskofbias__final=True,
riskofbias__active=True)
serializer = RiskOfBiasScoreSerializer(scores, many=True)
return serializer.data
class AssessmentRiskOfBiasScoreSerializer(serializers.ModelSerializer):
class Meta:
model = models.RiskOfBiasScore
fields = ('id', 'notes', 'score')
SerializerHelper.add_serializer(models.RiskOfBias, RiskOfBiasSerializer)
