clinicedc 2.0.1__py3-none-any.whl → 2.0.2__py3-none-any.whl

edc_form_validators/applicable_field_validator.py

@@ -16,9 +16,7 @@ class ApplicableFieldValidator(BaseFormValidator):
         msg: Optional[str] = None,
         applicable_msg: Optional[str] = None,
     ) -> None:
-        message = {
-            field: applicable_msg or f"This field is applicable. {msg or ''}".strip()
-        }
+        message = {field: applicable_msg or f"This field is applicable. {msg or ''}".strip()}
         self.raise_validation_error(message, APPLICABLE_ERROR)
 
     def raise_not_applicable(
@@ -28,8 +26,7 @@ class ApplicableFieldValidator(BaseFormValidator):
         not_applicable_msg: Optional[str] = None,
     ) -> None:
         message = {
-            field: not_applicable_msg
-            or f"This field is not applicable. {msg or ''}".strip()
+            field: not_applicable_msg or f"This field is not applicable. {msg or ''}".strip()
         }
         self.raise_validation_error(message, NOT_APPLICABLE_ERROR)
 
@@ -120,12 +117,9 @@ class ApplicableFieldValidator(BaseFormValidator):
             field_applicable_value = self.get(field_applicable)
 
             if field_value in responses and (
-                field_applicable_value is None
-                or field_applicable_value == not_applicable
+                field_applicable_value is None or field_applicable_value == not_applicable
             ):
-                self.raise_applicable(
-                    field_applicable, msg=msg, applicable_msg=applicable_msg
-                )
+                self.raise_applicable(field_applicable, msg=msg, applicable_msg=applicable_msg)
             elif (
                 field_value not in responses
                 and field_applicable_value != not_applicable
@@ -157,10 +151,7 @@ class ApplicableFieldValidator(BaseFormValidator):
         if is_instance_field:
             self.update_cleaned_data_from_instance(field)
         if field in self.cleaned_data and field_applicable in self.cleaned_data:
-            if (
-                self.get(field) in responses
-                and self.get(field_applicable) != not_applicable
-            ):
+            if self.get(field) in responses and self.get(field_applicable) != not_applicable:
                 self.raise_not_applicable(
                     field_applicable, msg=msg, not_applicable_msg=not_applicable_msg
                 )
@@ -168,9 +159,7 @@ class ApplicableFieldValidator(BaseFormValidator):
                 self.get(field) not in responses
                 and self.get(field_applicable) == not_applicable
             ):
-                self.raise_applicable(
-                    field_applicable, msg=msg, applicable_msg=applicable_msg
-                )
+                self.raise_applicable(field_applicable, msg=msg, applicable_msg=applicable_msg)
         return False
 
     def applicable_if_true(

edc_form_validators/base_form_validator.py

@@ -95,9 +95,7 @@ class BaseFormValidator:
                 field_value = self.cleaned_data.get(field)
         return field_value
 
-    def raise_validation_error(
-        self, message: dict[str, str] | str, error_code: str
-    ) -> None:
+    def raise_validation_error(self, message: dict[str, str] | str, error_code: str) -> None:
         if isinstance(message, str):
             message = {NON_FIELD_ERRORS: message}
         self._errors.update(message)

edc_form_validators/date_range_validator.py

@@ -39,9 +39,7 @@ class DateRangeFieldValidator(BaseFormValidator):
         msg = msg or f"Invalid. Cannot be before {date_field1} "
         if date1 and date2:
             if date1 > date2:
-                raise forms.ValidationError(
-                    {message_on_field or date_field2: f"{msg}."}
-                )
+                raise forms.ValidationError({message_on_field or date_field2: f"{msg}."})
 
     def date_not_after(
         self,
@@ -111,9 +109,7 @@ class DateRangeFieldValidator(BaseFormValidator):
                     {datetime_field1: f"{msg}. Got {formatted_datetime(datetime2)}."}
                 )
 
-    def datetime_not_after(
-        self, datetime_field1: str, datetime_field2: str, msg=None
-    ) -> None:
+    def datetime_not_after(self, datetime_field1: str, datetime_field2: str, msg=None) -> None:
         datetime_field1 = self.cleaned_data.get(datetime_field1)
         datetime_field2 = self.cleaned_data.get(datetime_field2)
         msg = msg or f"Invalid. Cannot be before date of {datetime_field2} "
@@ -123,9 +119,7 @@ class DateRangeFieldValidator(BaseFormValidator):
             if datetime_field1 > datetime_field2:
                 raise forms.ValidationError({datetime_field1: f"{msg}"})
 
-    def datetime_equal(
-        self, datetime_field1: str, datetime_field2: str, msg=None
-    ) -> None:
+    def datetime_equal(self, datetime_field1: str, datetime_field2: str, msg=None) -> None:
         datetime_field1 = self.cleaned_data.get(datetime_field1)
         datetime_field2 = self.cleaned_data.get(datetime_field2)
         msg = msg or f"Invalid. Cannot be before date of {datetime_field2} "
@@ -134,7 +128,5 @@ class DateRangeFieldValidator(BaseFormValidator):
             datetime_field2 = to_utc(datetime_field2)
             if datetime_field1 == datetime_field2:
                 raise forms.ValidationError(
-                    {
-                        datetime_field1: f"{msg}. Got {formatted_datetime(datetime_field2)}."
-                    }
+                    {datetime_field1: f"{msg}. Got {formatted_datetime(datetime_field2)}."}
                 )

edc_form_validators/date_validator.py

@@ -40,9 +40,7 @@ class DateValidator(BaseFormValidator):
         )
         field_value = field_value or self._get_as_date(field)
         if field_value and reference_value:
-            if not self._compare_date_to_reference_value(
-                op, field_value, reference_value
-            ):
+            if not self._compare_date_to_reference_value(op, field_value, reference_value):
                 if field:
                     self.raise_validation_error({field: msg}, INVALID_ERROR)
                 else:
@@ -197,9 +195,7 @@ class DateValidator(BaseFormValidator):
         """Convenience method if comparing with report_datetime."""
         msg = None
         report_datetime_field = report_datetime_field or "report_datetime"
-        if self.cleaned_data.get(field) and self.cleaned_data.get(
-            report_datetime_field
-        ):
+        if self.cleaned_data.get(field) and self.cleaned_data.get(report_datetime_field):
             dte = self.cleaned_data.get(report_datetime_field).strftime(
                 convert_php_dateformat(settings.DATETIME_FORMAT)
             )
@@ -221,9 +217,7 @@ class DateValidator(BaseFormValidator):
         """Convenience method if comparing with report_datetime."""
         msg = None
         report_datetime_field = report_datetime_field or "report_datetime"
-        if self.cleaned_data.get(field) and self.cleaned_data.get(
-            report_datetime_field
-        ):
+        if self.cleaned_data.get(field) and self.cleaned_data.get(report_datetime_field):
             dte = self.cleaned_data.get(report_datetime_field).strftime(
                 convert_php_dateformat(settings.DATETIME_FORMAT)
             )

edc_form_validators/many_to_many_field_validator.py

@@ -124,9 +124,7 @@ class ManyToManyFieldValidator(BaseFormValidator):
         """
         code: Optional[str] = None
         message: dict = {}
-        if self.cleaned_data.get(field) == response and not self.cleaned_data.get(
-            m2m_field
-        ):
+        if self.cleaned_data.get(field) == response and not self.cleaned_data.get(m2m_field):
             message = {m2m_field: "This field is required"}
             code = REQUIRED_ERROR
         elif (

edc_form_validators/other_specify_field_validator.py

@@ -47,9 +47,7 @@ class OtherSpecifyFieldValidator(BaseFormValidator):
             and not cleaned_data.get(other_specify_field)
         ):
             ref = "" if not ref else f" ref: {ref}"
-            message = {
-                other_specify_field: required_msg or f"This field is required.{ref}"
-            }
+            message = {other_specify_field: required_msg or f"This field is required.{ref}"}
             self._errors.update(message)
             self._error_codes.append(REQUIRED_ERROR)
             raise ValidationError(message, code=REQUIRED_ERROR)
@@ -60,8 +58,7 @@ class OtherSpecifyFieldValidator(BaseFormValidator):
         ):
             ref = "" if not ref else f" ref: {ref}"
             message = {
-                other_specify_field: not_required_msg
-                or f"This field is not required.{ref}"
+                other_specify_field: not_required_msg or f"This field is not required.{ref}"
             }
             self._errors.update(message)
             self._error_codes.append(NOT_REQUIRED_ERROR)
@@ -69,8 +66,7 @@ class OtherSpecifyFieldValidator(BaseFormValidator):
         elif field_value is None and cleaned_data.get(other_specify_field):
             ref = "" if not ref else f" ref: {ref}"
             message = {
-                other_specify_field: not_required_msg
-                or f"This field is not required.{ref}"
+                other_specify_field: not_required_msg or f"This field is not required.{ref}"
             }
             self._errors.update(message)
             self._error_codes.append(NOT_REQUIRED_ERROR)

edc_form_validators/range_field_validator.py

@@ -28,9 +28,7 @@ class RangeFieldValidator(BaseFormValidator):
             if value is None and allow_none:
                 pass
             elif value is None and not allow_none:
-                self.raise_validation_error(
-                    {field: "This field is required."}, REQUIRED_ERROR
-                )
+                self.raise_validation_error({field: "This field is required."}, REQUIRED_ERROR)
             elif r.match(str(value)):
                 lower_op = "<" if not lower_inclusive else "<="
                 upper_op = "<" if not upper_inclusive else "<="

edc_form_validators/required_field_validator.py

@@ -23,9 +23,7 @@ class RequiredFieldValidator(BaseFormValidator):
         self, field: str, msg: Optional[str] = None, inline_set: Optional[str] = None
     ) -> None:
         if inline_set:
-            default_errmsg = _(
-                "Based on your responses, inline information is required."
-            )
+            default_errmsg = _("Based on your responses, inline information is required.")
             message = {"__all__": (msg or default_errmsg).strip()}
         else:
             errmsg = _("This field is required")
@@ -37,9 +35,7 @@ class RequiredFieldValidator(BaseFormValidator):
         self, field: str, msg: Optional[str] = None, inline_set: Optional[str] = None
     ) -> None:
         if inline_set:
-            default_errmsg = _(
-                "Based on your responses, inline information is not required."
-            )
+            default_errmsg = _("Based on your responses, inline information is not required.")
             message = {"__all__": (msg or default_errmsg).strip()}
         else:
             errmsg = _("This field is not required")
@@ -113,10 +109,7 @@ class RequiredFieldValidator(BaseFormValidator):
                 field_value not in responses
                 and (
                     field_required_has_value
-                    and (
-                        self.get(field_required, inline_set=inline_set)
-                        != NOT_APPLICABLE
-                    )
+                    and (self.get(field_required, inline_set=inline_set) != NOT_APPLICABLE)
                 )
             ):
                 self.raise_not_required(
@@ -252,11 +245,7 @@ class RequiredFieldValidator(BaseFormValidator):
             self.update_cleaned_data_from_instance(field)
         self._inspect_params(*responses, field=field, field_required=field_required)
         if field in self.cleaned_data and field_required in self.cleaned_data:
-            if (
-                DWTA in responses
-                and optional_if_dwta
-                and self.cleaned_data.get(field) == DWTA
-            ):
+            if DWTA in responses and optional_if_dwta and self.cleaned_data.get(field) == DWTA:
                 pass
             elif self.cleaned_data.get(field) in responses and (
                 self.cleaned_data.get(field_required)
@@ -304,9 +293,7 @@ class RequiredFieldValidator(BaseFormValidator):
             errmsg = _("`field` cannot be `None`")
             raise InvalidModelFormFieldValidator(f"{errmsg}.")
         elif not responses:
-            errmsg = _(
-                f"At least one valid response for field '{field}' must be provided."
-            )
+            errmsg = _(f"At least one valid response for field '{field}' must be provided.")
             raise InvalidModelFormFieldValidator(errmsg)
         elif not field_required:
             raise InvalidModelFormFieldValidator('"field_required" cannot be None.')

edc_glucose/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig as DjangoAppConfig
+
+
+class AppConfig(DjangoAppConfig):
+    name = "edc_glucose"
+    verbose_name = "Edc Glucose"

edc_glucose/constants.py

@@ -0,0 +1,3 @@
+from django.conf import settings
+
+GLUCOSE_HIGH_READING = getattr(settings, "EDC_GLUCOSE_HIGH_READING", 9999.99)

edc_glucose/fieldsets.py

@@ -0,0 +1,14 @@
+glucose_fieldset_tuple: tuple[str, dict[str, tuple]] = (
+    "Blood Glucose Measurement",
+    {
+        "fields": (
+            "glucose_performed",
+            "glucose_fasting",
+            "glucose_fasting_duration_str",
+            "glucose_date",
+            "glucose_value",
+            "glucose_quantifier",
+            "glucose_units",
+        ),
+    },
+)

edc_glucose/form_validators/__init__.py

@@ -0,0 +1,6 @@
+from .fasting_form_validator import FastingFormValidatorMixin
+from .fbg_form_validator_mixin import FbgFormValidatorMixin
+from .fbg_ogtt_form_validator_mixin import FbgOgttFormValidatorMixin
+from .glucose_form_validator import GlucoseFormValidator
+from .glucose_form_validator_mixin import GlucoseFormValidatorMixin
+from .ogtt_form_validator_mixin import OgttFormValidatorMixin

edc_glucose/form_validators/fasting_form_validator.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from edc_constants.constants import YES
+
+
+class FastingFormValidatorMixin:
+    def validate_fasting_required_fields(self, fasting_prefix: str | None = None):
+        """Uses fields `fasting`,`fasting_duration_str`"""
+        fasting_prefix = fasting_prefix or "fasting"
+        self.required_if(
+            YES, field=fasting_prefix, field_required=f"{fasting_prefix}_duration_str"
+        )

edc_glucose/form_validators/fbg_form_validator_mixin.py

@@ -0,0 +1,32 @@
+from edc_form_validators import FormValidator
+
+
+class FbgFormValidatorMixin:
+    """Declare with FormValidatorMixin, modelform"""
+
+    def validate_fbg_required_fields(self: FormValidator, fbg_prefix: str):
+        """Uses fields `fbg_value`, `fbg_datetime`, `fbg_units`.
+
+        Args:
+            :param fbg_prefix: e.g. fbg, fbg2, etc
+        """
+
+        self.date_is_after_or_raise(
+            field=f"{fbg_prefix}_datetime",
+            reference_field=self.report_datetime_field_attr,
+            inclusive=True,
+        )
+        self.required_if_true(
+            self.cleaned_data.get(f"{fbg_prefix}_datetime"),
+            field_required=f"{fbg_prefix}_value",
+        )
+
+        self.required_if_true(
+            self.cleaned_data.get(f"{fbg_prefix}_value"),
+            field_required=f"{fbg_prefix}_units",
+        )
+
+        self.required_if_true(
+            self.cleaned_data.get(f"{fbg_prefix}_value"),
+            field_required=f"{fbg_prefix}_datetime",
+        )

edc_glucose/form_validators/fbg_ogtt_form_validator_mixin.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from django import forms
+
+from ..utils import validate_glucose_as_millimoles_per_liter
+from .fbg_form_validator_mixin import FbgFormValidatorMixin
+from .ogtt_form_validator_mixin import OgttFormValidatorMixin
+
+
+class FbgOgttFormValidatorMixin(FbgFormValidatorMixin, OgttFormValidatorMixin):
+    def validate_glucose_testing_matrix(
+        self,
+        ogtt_prefix: str | None = None,
+        fbg_prefix: str | None = None,
+        include_fbg: bool | None = None,
+    ) -> None:
+        ogtt_prefix = ogtt_prefix or "ogtt"
+        fbg_prefix = fbg_prefix or "fbg"
+
+        include_fbg = True if include_fbg is None else include_fbg
+        if include_fbg:
+            self.validate_fbg_required_fields(fbg_prefix)
+            validate_glucose_as_millimoles_per_liter(fbg_prefix, self.cleaned_data)
+        self.validate_ogtt_required_fields(ogtt_prefix=ogtt_prefix)
+        validate_glucose_as_millimoles_per_liter(ogtt_prefix, self.cleaned_data)
+        self.validate_ogtt_dates(ogtt_prefix=ogtt_prefix)
+        self.validate_fbg_before_ogtt(ogtt_prefix=ogtt_prefix, fbg_prefix=fbg_prefix)
+        self.validate_ogtt_time_interval()
+
+    def validate_fbg_before_ogtt(
+        self, ogtt_prefix: str | None = None, fbg_prefix: str | None = None
+    ):
+        """Validate the FBG is performed before the OGTT"""
+        ogtt_prefix = ogtt_prefix or "ogtt"
+        fbg_prefix = fbg_prefix or "fbg"
+        fbg_dte = self.cleaned_data.get(f"{fbg_prefix}_datetime")
+        ogtt_base_dte = self.cleaned_data.get(f"{ogtt_prefix}_base_datetime")
+        if fbg_dte and ogtt_base_dte:
+            total_seconds = (ogtt_base_dte - fbg_dte).total_seconds()
+            if total_seconds <= 1:
+                raise forms.ValidationError(
+                    {
+                        f"{ogtt_prefix}_base_datetime": (
+                            "Invalid date. Expected to be after time FBG level was measured"
+                        )
+                    }
+                )

edc_glucose/form_validators/glucose_form_validator.py

@@ -0,0 +1,44 @@
+from edc_dx_review.utils import (
+    raise_if_clinical_review_does_not_exist,
+    raise_if_initial_review_does_not_exist,
+)
+
+from edc_constants.constants import DM
+from edc_crf.crf_form_validator_mixins import CrfFormValidatorMixin
+from edc_form_validators import FormValidator
+from edc_visit_schedule.utils import raise_if_baseline
+
+from .glucose_form_validator_mixin import GlucoseFormValidatorMixin
+
+
+class GlucoseFormValidator(
+    GlucoseFormValidatorMixin,
+    CrfFormValidatorMixin,
+    FormValidator,
+):
+    """Declared as an example of the clean method to use with
+    the mixin.
+    """
+
+    required_at_baseline = True
+    require_diagnosis = False
+    require_clinical_review_crf = True
+    prefix = "glucose"
+
+    def clean(self):
+        if self.cleaned_data.get("subject_visit"):
+            if not self.required_at_baseline:
+                raise_if_baseline(self.cleaned_data.get("subject_visit"))
+            self.raise_if_clinical_review_does_not_exist()
+            if self.require_diagnosis:
+                raise_if_initial_review_does_not_exist(
+                    self.cleaned_data.get("subject_visit"), DM
+                )
+            self.validate_glucose_test()
+
+    def raise_if_clinical_review_does_not_exist(self) -> None:
+        if self.require_clinical_review_crf:
+            return raise_if_clinical_review_does_not_exist(
+                self.cleaned_data.get("subject_visit")
+            )
+        return None

edc_glucose/form_validators/glucose_form_validator_mixin.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from dateutil.relativedelta import relativedelta
+
+from edc_constants.constants import YES
+
+from ..utils import validate_glucose_as_millimoles_per_liter
+
+INVALID_GLUCOSE_DATE = "INVALID_GLUCOSE_DATE"
+
+
+class GlucoseFormValidatorMixin:
+    prefix: str | None = None
+
+    def validate_glucose_test(self, prefix: str | None = None) -> None:
+        prefix = prefix or self.prefix or "glucose"
+        self.applicable_if(
+            YES, field=f"{prefix}_performed", field_applicable=f"{prefix}_fasting"
+        )
+        self.required_if(
+            YES,
+            field=f"{prefix}_fasting",
+            field_required=f"{prefix}_fasting_duration_str",
+        )
+        self.required_if(YES, field=f"{prefix}_performed", field_required=f"{prefix}_date")
+        self.required_if(YES, field=f"{prefix}_performed", field_required=f"{prefix}_value")
+        validate_glucose_as_millimoles_per_liter(prefix, self.cleaned_data)
+        self.required_if(
+            YES, field=f"{prefix}_performed", field_required=f"{prefix}_quantifier"
+        )
+        self.required_if(YES, field=f"{prefix}_performed", field_required=f"{prefix}_units")
+
+    def validate_test_date_within_max_months(
+        self, date_fld: str, max_months: int | None = None
+    ):
+        max_months = max_months or 6
+        if self.cleaned_data.get(date_fld) and self.cleaned_data.get("report_datetime"):
+            try:
+                dt = self.cleaned_data.get(date_fld).date()
+            except AttributeError:
+                dt = self.cleaned_data.get(date_fld)
+            report_datetime = self.cleaned_data.get("report_datetime").date()
+            rdelta = relativedelta(report_datetime, dt)
+            months = rdelta.months + (12 * rdelta.years)
+            if months >= max_months or months < 0:
+                if months < 0:
+                    msg = "Invalid. Cannot be a future date."
+                else:
+                    msg = (
+                        f"Invalid. Must be within the last {max_months} months. "
+                        f"Got {abs(months)}m ago."
+                    )
+                self.raise_validation_error({date_fld: msg}, INVALID_GLUCOSE_DATE)

edc_glucose/form_validators/ogtt_form_validator_mixin.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from django import forms
+
+from edc_constants.constants import NO
+
+
+class OgttFormValidatorMixin:
+    def validate_ogtt_required_fields(
+        self,
+        ogtt_prefix: str | None = None,
+        fasting_prefix: str | None = None,
+    ) -> None:
+        """Uses fields `fasting`, `ogtt_base_datetime`, `ogtt_datetime`,
+        `ogtt_value`, `ogtt_units`
+        """
+        ogtt = ogtt_prefix or "ogtt"
+        fasting = fasting_prefix or "fasting"
+        self.required_if_true(
+            self.cleaned_data.get(f"{ogtt}_datetime"),
+            field_required=f"{ogtt}_value",
+            inverse=False,
+        )
+
+        self.required_if_true(
+            self.cleaned_data.get(f"{ogtt}_value"),
+            field_required=f"{ogtt}_datetime",
+            inverse=False,
+        )
+
+        self.not_required_if(
+            NO,
+            field=fasting,
+            field_not_required=f"{ogtt}_base_datetime",
+            inverse=False,
+        )
+        self.not_required_if(
+            NO, field=fasting, field_not_required=f"{ogtt}_datetime", inverse=False
+        )
+        self.not_required_if(
+            NO, field=fasting, field_not_required=f"{ogtt}_value", inverse=False
+        )
+
+        self.required_if_true(
+            self.cleaned_data.get(f"{ogtt}_value"),
+            field_required=f"{ogtt}_units",
+        )
+
+        self.not_required_if(
+            NO, field=fasting, field_not_required=f"{ogtt}_units", inverse=False
+        )
+
+    def validate_ogtt_dates(self, ogtt_prefix: str | None = None) -> None:
+        ogtt = ogtt_prefix or "ogtt"
+        ogtt_base_dte = self.cleaned_data.get(f"{ogtt}_base_datetime")
+        ogtt_dte = self.cleaned_data.get(f"{ogtt}_datetime")
+        if ogtt_base_dte and ogtt_dte:
+            tdelta = ogtt_dte - ogtt_base_dte
+            if tdelta.total_seconds() < 3600:
+                raise forms.ValidationError(
+                    {
+                        f"{ogtt}_datetime": (
+                            "Invalid. Expected more time between OGTT initial and 2hr."
+                        )
+                    }
+                )
+            if tdelta.seconds > (3600 * 5):
+                raise forms.ValidationError(
+                    {
+                        f"{ogtt}_datetime": (
+                            "Invalid. Expected less time between OGTT initial and 2hr."
+                        )
+                    }
+                )
+
+    def validate_ogtt_time_interval(self, ogtt_prefix: str | None = None) -> None:
+        """Validate the OGTT is measured 2 hrs after base date"""
+        ogtt = ogtt_prefix or "ogtt"
+        ogtt_base_dte = self.cleaned_data.get(f"{ogtt}_base_datetime")
+        ogtt_dte = self.cleaned_data.get(f"{ogtt}_datetime")
+        if ogtt_base_dte and ogtt_dte:
+            diff = (ogtt_dte - ogtt_base_dte).total_seconds() / 60.0
+            if diff <= 1.0:
+                raise forms.ValidationError(
+                    {
+                        f"{ogtt}_datetime": (
+                            "Invalid date. Expected to be after time oral glucose "
+                            f"tolerance test was performed. ({diff})"
+                        )
+                    }
+                )

edc_glucose/list_filters.py

@@ -0,0 +1,42 @@
+from decimal import Decimal
+
+from django.contrib.admin import SimpleListFilter
+
+__all__ = ["FbgListFilter", "OgttListFilter"]
+
+
+class FbgListFilter(SimpleListFilter):
+    title = "FBG"
+    parameter_name = "fbg_value"
+
+    def lookups(self, request, model_admin):
+        return (
+            ("fbg_normal", "below 7.0 mmol/L"),
+            ("fbg_high", "above 7.0 mmol/L (incl)"),
+        )
+
+    def queryset(self, request, queryset):
+        self.value()
+        if self.value() == "fbg_normal":
+            return queryset.filter(fbg_value__lt=Decimal("7.0"))
+        if self.value() == "fbg_high":
+            return queryset.filter(fbg_value__gte=Decimal("7.0"))
+        return queryset
+
+
+class OgttListFilter(SimpleListFilter):
+    title = "OGTT"
+    parameter_name = "ogtt_value"
+
+    def lookups(self, request, model_admin):
+        return (
+            ("ogtt_normal", "below 11.1 mmol/L"),
+            ("ogtt_high", "above 11.1 mmol/L (incl)"),
+        )
+
+    def queryset(self, request, queryset):
+        if self.value() == "ogtt_normal":
+            return queryset.filter(ogtt_value__lt=Decimal("11.1"))
+        if self.value() == "ogtt_high":
+            return queryset.filter(ogtt_value__gte=Decimal("11.1"))
+        return queryset

edc_glucose/model_mixin_factories/__init__.py

@@ -0,0 +1,4 @@
+from .fasting_model_mixin_factory import fasting_model_mixin_factory
+from .fbg_model_mixin_factory import fbg_model_mixin_factory
+from .glucose_model_mixin_factory import glucose_model_mixin_factory
+from .ogtt_model_mixin_factory import ogtt_model_mixin_factory