epiv2 CRUD api

hawc/apps/common/serializers.py

@@ -5,6 +5,7 @@
 from django.core.exceptions import ObjectDoesNotExist
 from django.db import models
 from django.utils import timezone
+from django.utils.translation import gettext_lazy as _
 from pydantic import BaseModel
 from pydantic import ValidationError as PydanticError
 from rest_framework import serializers
@@ -162,6 +163,59 @@ def to_internal_value(self, data):
         self.fail("invalid_choice", input=data)
 
 
+class ArrayedFlexibleChoiceField(serializers.ChoiceField):
+    """
+    like FlexibleChoiceField; accepts either the raw choice value OR a case-insensitive
+    display value when supplying data, intended for choice fields wrapped in an ArrayField
+    """
+
+    # dupe invalid_choice in ChoiceField, and create a new one that we'll use
+    default_error_messages = {
+        "invalid_choice": _('"{input}" is not a valid choice.'),
+        "full_custom": _("{input}"),
+    }
+
+    def to_representation(self, obj):
+        if len(obj) == 0 and self.allow_blank:
+            return obj
+        return [self._choices[x] for x in obj]
+
+    def to_internal_value(self, data):
+        if (data is None or len(data) == 0) and self.allow_blank:
+            return []
+        else:
+            converted_values = []
+            invalid_values = []
+            for x in data:
+                element_handled = False
+                # Look for an exact match of either key or val
+                for key, val in self._choices.items():
+                    if key == x or val == x:
+                        converted_values.append(key)
+                        element_handled = True
+                        break
+
+                if not element_handled:
+                    # No exact match; if a string was passed in let's try case-insensitive value match
+                    if type(x) is str:
+                        key = get_id_from_choices(self._choices.items(), x)
+                        if key is not None:
+                            converted_values.append(key)
+                            element_handled = True
+
+                if not element_handled:
+                    invalid_values.append(x)
+
+            if len(invalid_values) == 0:
+                return converted_values
+            else:
+                invalid_summary = ", ".join([f"'{x}'" for x in invalid_values])
+                self.fail(
+                    "full_custom",
+                    input=f"input {data} contained invalid value(s): {invalid_summary}.",
+                )
+
+
 class FlexibleDBLinkedChoiceField(FlexibleChoiceField):
     """
     FlexibleChoiceField subclass which derives its choices from a model/database table and optionally supports multiples.

hawc/apps/epiv2/api.py

@@ -47,3 +47,45 @@ def get_queryset(self, *args, **kwargs):
 class Metadata(viewsets.ViewSet):
     def list(self, request):
         return EpiV2Metadata.handle_request(request)
+
+
+class Chemical(EditPermissionsCheckMixin, AssessmentEditViewset):
+    edit_check_keys = ["design"]
+    assessment_filter_args = "design__study__assessment"
+    model = models.Chemical
+    serializer_class = serializers.ChemicalSerializer
+
+
+class Exposure(EditPermissionsCheckMixin, AssessmentEditViewset):
+    edit_check_keys = ["design"]
+    assessment_filter_args = "design__study__assessment"
+    model = models.Exposure
+    serializer_class = serializers.ExposureSerializer
+
+
+class ExposureLevel(EditPermissionsCheckMixin, AssessmentEditViewset):
+    edit_check_keys = ["design"]
+    assessment_filter_args = "design__study__assessment"
+    model = models.ExposureLevel
+    serializer_class = serializers.ExposureLevelSerializer
+
+
+class Outcome(EditPermissionsCheckMixin, AssessmentEditViewset):
+    edit_check_keys = ["design"]
+    assessment_filter_args = "design__study__assessment"
+    model = models.Outcome
+    serializer_class = serializers.OutcomeSerializer
+
+
+class AdjustmentFactor(EditPermissionsCheckMixin, AssessmentEditViewset):
+    edit_check_keys = ["design"]
+    assessment_filter_args = "design__study__assessment"
+    model = models.AdjustmentFactor
+    serializer_class = serializers.AdjustmentFactorSerializer
+
+
+class DataExtraction(EditPermissionsCheckMixin, AssessmentEditViewset):
+    edit_check_keys = ["design"]
+    assessment_filter_args = "design__study__assessment"
+    model = models.DataExtraction
+    serializer_class = serializers.DataExtractionSerializer

hawc/apps/epiv2/mixins.py

@@ -0,0 +1,69 @@
+from rest_framework import exceptions, serializers
+
+from .models import Design
+
+
+class BelongsToSameDesignMixin:
+    """
+    ex: when updating an ExposureLevel, there's a related Chemical and Exposure sometimes passed into the payload as
+    "chemical_id" and "exposure_level_id". Basic DRF functionality verifies that the supplied values are valid
+    items in the database, but it's a common requirement that they also belong to the same parent object; in this
+    case, the same design. This mixin performs that type of validation logic.
+
+    Could potentially generalize this even further (so that it's not just useful for "Design"); this type of
+    relationship is not uncommon.
+    """
+
+    def validate(self, data):
+        fields_to_check = []
+        try:
+            fields_to_check = self.belongs_to_same_design_fields
+
+            # first off - were any of the parameters we're concerned with in the payload? If not, there's
+            # no need to perform any custom validation.
+            perform_custom_validation = False
+            for field_to_check in fields_to_check:
+                param_name = field_to_check[0]
+                if param_name in self.initial_data:
+                    perform_custom_validation = True
+                    break
+
+            if perform_custom_validation is True:
+                # figure out what design we're concerned with...
+                if "design" in self.initial_data:
+                    # load from the supplied payload...
+                    design_id = self.initial_data.get("design")
+                    design = Design.objects.get(id=design_id)
+                else:
+                    # load from the previously saved state; the APIException here should never happen but just in case...
+                    if self.instance is not None:
+                        design = self.instance.design
+                    else:
+                        raise exceptions.APIException(
+                            "validation failed; could not determine relevant design id"
+                        )
+
+            invalid_fields = []
+            for field_to_check in fields_to_check:
+                param_name = field_to_check[0]
+                model_klass = field_to_check[1]
+
+                if param_name in self.initial_data:
+                    candidate_id = self.initial_data.get(param_name)
+                    candidate_obj = model_klass.objects.get(id=candidate_id)
+
+                    if candidate_obj.design.id != design.id:
+                        invalid_fields.append(
+                            (
+                                param_name,
+                                f"object with id={candidate_id} does not belong to the correct design.",
+                            )
+                        )
+            if len(invalid_fields) > 0:
+                raise serializers.ValidationError({x[0]: x[1] for x in invalid_fields})
+        except AttributeError:
+            raise Exception(
+                f"{type(self).__name__} is configured to mixin BelongsToSameDesignMixin but lacks a properly configured property 'belongs_to_same_design_fields'"
+            )
+
+        return super().validate(data)

hawc/apps/epiv2/serializers.py

@@ -1,77 +1,168 @@
 from django.db import transaction
 from rest_framework import serializers
 
-from ..common.serializers import FlexibleChoiceField, IdLookupMixin
+from ..assessment.models import DSSTox
+from ..assessment.serializers import DSSToxSerializer
+from ..common.serializers import ArrayedFlexibleChoiceField, FlexibleChoiceField, IdLookupMixin
 from ..epi.serializers import StudyPopulationCountrySerializer
+from ..study.models import Study
 from ..study.serializers import StudySerializer
-from . import constants, models
+from . import constants, mixins, models
 
 
 class ChemicalSerializer(serializers.ModelSerializer):
+    dsstox_id = serializers.PrimaryKeyRelatedField(
+        write_only=True,
+        source="dsstox",
+        queryset=DSSTox.objects.all(),
+        required=False,
+        allow_null=True,
+    )
+    dsstox = DSSToxSerializer(read_only=True)
+
     class Meta:
         model = models.Chemical
-        fields = ["id", "name", "dsstox"]
+        fields = ["id", "design", "name", "dsstox_id", "dsstox"]
 
 
 class ExposureSerializer(serializers.ModelSerializer):
     exposure_route = FlexibleChoiceField(choices=constants.ExposureRoute.choices)
+    biomonitoring_matrix = FlexibleChoiceField(
+        choices=constants.BiomonitoringMatrix.choices, allow_blank=True
+    )
+    biomonitoring_source = FlexibleChoiceField(
+        choices=constants.BiomonitoringSource.choices, allow_blank=True
+    )
 
     class Meta:
         model = models.Exposure
-        exclude = ["design", "created", "last_updated"]
-
+        exclude = ["created", "last_updated"]
+
+
+class ExposureLevelSerializer(mixins.BelongsToSameDesignMixin, serializers.ModelSerializer):
+    variance_type = FlexibleChoiceField(choices=constants.VarianceType.choices)
+    ci_type = FlexibleChoiceField(choices=constants.ConfidenceIntervalType.choices)
+
+    belongs_to_same_design_fields = [
+        ("chemical_id", models.Chemical),
+        ("exposure_measurement_id", models.Exposure),
+    ]
+
+    chemical_id = serializers.PrimaryKeyRelatedField(
+        write_only=True,
+        source="chemical",
+        queryset=models.Chemical.objects.all(),
+        required=True,
+        allow_null=False,
+    )
+    chemical = ChemicalSerializer(read_only=True)
+    exposure_measurement_id = serializers.PrimaryKeyRelatedField(
+        write_only=True,
+        source="exposure_measurement",
+        queryset=models.Exposure.objects.all(),
+        required=True,
+        allow_null=False,
+    )
+    exposure_measurement = ExposureSerializer(read_only=True)
 
-class ExposureLevelSerializer(serializers.ModelSerializer):
     class Meta:
         model = models.ExposureLevel
-        exclude = ["design", "created", "last_updated"]
+        exclude = ["created", "last_updated"]
 
 
 class OutcomeSerializer(serializers.ModelSerializer):
+    system = FlexibleChoiceField(choices=constants.HealthOutcomeSystem.choices)
+
     class Meta:
         model = models.Outcome
-        exclude = ["design", "created", "last_updated"]
+        exclude = ["created", "last_updated"]
 
 
 class AdjustmentFactorSerializer(serializers.ModelSerializer):
     class Meta:
         model = models.AdjustmentFactor
-        exclude = ["design", "created", "last_updated"]
+        exclude = ["created", "last_updated"]
+
+
+class DataExtractionSerializer(mixins.BelongsToSameDesignMixin, serializers.ModelSerializer):
+    ci_type = FlexibleChoiceField(choices=constants.ConfidenceIntervalType.choices)
+    variance_type = FlexibleChoiceField(choices=constants.VarianceType.choices)
+    significant = FlexibleChoiceField(choices=constants.Significant.choices)
+
+    belongs_to_same_design_fields = [
+        ("outcome_id", models.Outcome),
+        ("exposure_level_id", models.ExposureLevel),
+        ("factors_id", models.AdjustmentFactor),
+    ]
+
+    outcome_id = serializers.PrimaryKeyRelatedField(
+        write_only=True,
+        source="outcome",
+        queryset=models.Outcome.objects.all(),
+        required=True,
+        allow_null=False,
+    )
+    outcome = OutcomeSerializer(read_only=True)
+
+    exposure_level_id = serializers.PrimaryKeyRelatedField(
+        write_only=True,
+        source="exposure_level",
+        queryset=models.ExposureLevel.objects.all(),
+        required=True,
+        allow_null=False,
+    )
+    exposure_level = ExposureLevelSerializer(read_only=True)
+
+    factors_id = serializers.PrimaryKeyRelatedField(
+        write_only=True,
+        source="factors",
+        queryset=models.AdjustmentFactor.objects.all(),
+        required=False,
+        allow_null=True,
+    )
+    factors = AdjustmentFactorSerializer(read_only=True)
 
-
-class DataExtractionSerializer(serializers.ModelSerializer):
     class Meta:
         model = models.DataExtraction
-        exclude = ["design", "created", "last_updated"]
+        exclude = ["created", "last_updated"]
 
 
 class DesignSerializer(IdLookupMixin, serializers.ModelSerializer):
-    study = StudySerializer()
+    study_id = serializers.PrimaryKeyRelatedField(
+        write_only=True,
+        source="study",
+        queryset=Study.objects.all(),
+        required=True,
+        allow_null=False,
+    )
+    study = StudySerializer(read_only=True)
+
     study_design = FlexibleChoiceField(choices=constants.StudyDesign.choices)
+    age_profile = ArrayedFlexibleChoiceField(choices=constants.AgeProfile.choices)
     source = FlexibleChoiceField(choices=constants.Source.choices)
     sex = FlexibleChoiceField(choices=constants.Sex.choices)
     countries = StudyPopulationCountrySerializer(many=True)
     chemicals = ChemicalSerializer(many=True, read_only=True)
-    exposure = ExposureSerializer(many=True, read_only=True)
+    exposures = ExposureSerializer(many=True, read_only=True)
     exposure_levels = ExposureLevelSerializer(many=True, read_only=True)
     outcomes = OutcomeSerializer(many=True, read_only=True)
     adjustment_factors = AdjustmentFactorSerializer(many=True, read_only=True)
     data_extractions = DataExtractionSerializer(many=True, read_only=True)
     url = serializers.CharField(source="get_absolute_url", read_only=True)
 
+    nested_models = [
+        "countries",
+    ]
+
     @transaction.atomic
     def create(self, validated_data):
-        nested_models = [
-            "countries",
-        ]
-
         if "age_profile" not in validated_data:
             validated_data["age_profile"] = []
 
         nested_validated_data = {}
 
         # remove nested models from validated_data
-        for model in nested_models:
+        for model in self.nested_models:
             data = validated_data.pop(model, None)
             nested_validated_data.update({model: data})
 
@@ -84,6 +175,24 @@ def create(self, validated_data):
 
         return instance
 
+    @transaction.atomic
+    def update(self, instance, validated_data):
+        nested_validated_data = {}
+
+        # remove nested models from validated_data
+        for model in self.nested_models:
+            data = validated_data.pop(model, None)
+            nested_validated_data.update({model: data})
+
+        # execute inherited create method
+        instance = super().update(instance, validated_data)
+
+        # add nested models to the instance
+        if countries := nested_validated_data.get("countries"):
+            instance.countries.set(countries)
+
+        return instance
+
     class Meta:
         model = models.Design
-        fields = "__all__"
+        exclude = ["created", "last_updated"]