penracourses/atlas/filters.py

import django_filters

from .models import (
    Case,
    CaseCollection,
    Condition,
    Finding,
    PathologicalProcess,
    Presentation,
    QuestionSchema,
    Series,
    Structure,
    Subspecialty,
)
from django.contrib.auth.models import User
from django.db.models import Q


def get_authors(request):
    if request is None:
        return User.objects.none()

    if not request.user.groups.filter(name="atlas_editor").exists():
        queryset = User.objects.filter(id=request.user.id)
    else:
        queryset = User.objects.all()

    return queryset


def get_cases(request):
    if request is None:
        return Case.objects.none()

    if not request.user.groups.filter(name="atlas_editor").exists():
        queryset = Case.objects.filter(author__id=request.user.id)
    else:
        queryset = Case.objects.all()

    return queryset


def get_series(request):
    if request is None:
        return Series.objects.none()

    if not request.user.groups.filter(name="atlas_editor").exists():
        queryset = Series.objects.filter(author__id=request.user.id)
    else:
        queryset = Series.objects.all()

    return queryset


class CaseCollectionFilter(django_filters.FilterSet):
    author = django_filters.ModelMultipleChoiceFilter(
        queryset=get_authors, null_label="No author"
    )
    cases = django_filters.ModelMultipleChoiceFilter(
        queryset=get_cases, null_label="No cases"
    )

    class Meta:
        model = CaseCollection
        fields = (
            "archive",
            "author",
        )  # "site",

    def __init__(
        self,
        data=None,
        queryset=None,
        prefix=None,
        strict=None,
        user=None,
        request=None,
    ):
        if not request.user.groups.filter(name="atlas_editor").exists():
            queryset = queryset.prefetch_related("author").filter(
                author__id=request.user.id
            )
        super(CaseCollectionFilter, self).__init__(
            data=data, queryset=queryset, prefix=prefix, request=request
        )
        pass


class CaseFilter(django_filters.FilterSet):
    author = django_filters.ModelMultipleChoiceFilter(
        queryset=get_authors, null_label="No author"
    )
    series = django_filters.ModelMultipleChoiceFilter(
        queryset=get_series, null_label="No series"
    )
    differential_case = django_filters.ModelMultipleChoiceFilter(
        label="Differential",
        field_name="differentialcase__condition",
        # to_field_name="differential",
        queryset=Condition.objects.all(),
    )

    class Meta:
        model = Case
        fields = (
            "created_date",
            "open_access",
            "author",
            "differential_case",
        )  # "site",

    def __init__(
        self,
        data=None,
        queryset=None,
        prefix=None,
        strict=None,
        user=None,
        request=None,
    ):
        if not request.user.groups.filter(name="atlas_editor").exists():
            queryset = queryset.prefetch_related("author").filter(
                (Q(author__id=request.user.id) | Q(open_access=True))
            )
        super(CaseFilter, self).__init__(
            data=data, queryset=queryset, prefix=prefix, request=request
        )
        pass


class SeriesFilter(django_filters.FilterSet):
    case = django_filters.ModelMultipleChoiceFilter(
        queryset=get_cases, null_label="No case"
    )
    author = django_filters.ModelMultipleChoiceFilter(
        queryset=get_authors, null_label="No author"
    )

    class Meta:
        model = Series
        fields = ("modality", "case", "examination", "author")

    def __init__(
        self,
        data=None,
        queryset=None,
        prefix=None,
        strict=None,
        user=None,
        request=None,
    ):
        if not request.user.groups.filter(name="atlas_editor").exists():
            # queryset = queryset.filter(open_access=True) | queryset.filter(author__id=request.user.id)
            queryset = queryset.filter(author__id=request.user.id)
        super(SeriesFilter, self).__init__(
            data=data, queryset=queryset, prefix=prefix, request=request
        )
        pass


class ConditionFilter(django_filters.FilterSet):
    class Meta:
        model = Condition
        fields = {
            "name": ["icontains"],
            "primary": ["exact"],
            "synonym": ["exact"],
            #"parent": ["exact"],
            "subspecialty": ["exact"],
            "rcr_curriculum": ["exact"],
        }

    def __init__(
        self,
        data=None,
        queryset=None,
        prefix=None,
        strict=None,
        user=None,
        request=None,
    ):
        super(ConditionFilter, self).__init__(
            data=data, queryset=queryset, prefix=prefix, request=request
        )
        pass


class FindingFilter(django_filters.FilterSet):
    class Meta:
        model = Finding
        fields = ("name", "primary", "synonym")

    def __init__(
        self,
        data=None,
        queryset=None,
        prefix=None,
        strict=None,
        user=None,
        request=None,
    ):
        super(FindingFilter, self).__init__(
            data=data, queryset=queryset, prefix=prefix, request=request
        )
        pass


class StructureFilter(django_filters.FilterSet):
    class Meta:
        model = Structure
        fields = {"name": ["icontains"], "primary": ["exact"], "synonym": ["exact"]}

    def __init__(
        self,
        data=None,
        queryset=None,
        prefix=None,
        strict=None,
        user=None,
        request=None,
    ):
        super(StructureFilter, self).__init__(
            data=data, queryset=queryset, prefix=prefix, request=request
        )
        pass


class PresentationFilter(django_filters.FilterSet):
    class Meta:
        model = Presentation
        fields = ("name", "subspecialty")

    def __init__(
        self,
        data=None,
        queryset=None,
        prefix=None,
        strict=None,
        user=None,
        request=None,
    ):
        super(PresentationFilter, self).__init__(
            data=data, queryset=queryset, prefix=prefix, request=request
        )
        pass


class PathologicalProcessFilter(django_filters.FilterSet):
    class Meta:
        model = PathologicalProcess
        fields = ("name",)

    def __init__(
        self,
        data=None,
        queryset=None,
        prefix=None,
        strict=None,
        user=None,
        request=None,
    ):
        super(PathologicalProcessFilter, self).__init__(
            data=data, queryset=queryset, prefix=prefix, request=request
        )
        pass


class SubspecialtyFilter(django_filters.FilterSet):
    class Meta:
        model = Subspecialty
        fields = ("name",)

    def __init__(
        self,
        data=None,
        queryset=None,
        prefix=None,
        strict=None,
        user=None,
        request=None,
    ):
        super(SubspecialtyFilter, self).__init__(
            data=data, queryset=queryset, prefix=prefix, request=request
        )
        pass

class QuestionSchemaFilter(django_filters.FilterSet):
    class Meta:
        model = QuestionSchema
        fields = ("name", "description")