graphql_schema.py

import graphene
from django.contrib.auth import get_user_model
from graphene_django.types import DjangoObjectType
from graphene_django.views import GraphQLView

from portal.models import DataFile, DataSet, Profile
from portal.views import TokenLoginMixin


# Protect graphql API page
class PrivateGraphQLView(TokenLoginMixin, GraphQLView):
    pass


# Create a GraphQL type for the various models
class DataFileType(DjangoObjectType):
    class Meta:
        model = DataFile
        fields = "__all__"


class DataSetType(DjangoObjectType):
    class Meta:
        model = DataSet
        fields = "__all__"


class ProfileSetType(DjangoObjectType):
    class Meta:
        model = Profile


class UserType(DjangoObjectType):
    class Meta:
        model = get_user_model()


# Create a Query type
class Query(graphene.ObjectType):
    datafile = graphene.Field(DataFileType, id=graphene.String(), dbid=graphene.Int())
    dataset = graphene.Field(DataSetType, id=graphene.String(), dbid=graphene.Int())
    datafiles = graphene.List(DataFileType, key=graphene.String(), value=graphene.String(), dataset=graphene.String())
    datasets = graphene.List(DataSetType)

    def resolve_datafile(self, info, **kwargs):
        id = kwargs.get('id')
        dbid = kwargs.get('dbid')

        if id is not None:
            return DataFile.objects.get(iric_data_id=id)
        elif dbid is not None:
            return DataFile.objects.get(pk=dbid)

    def resolve_dataset(self, info, **kwargs):
        id = kwargs.get('id')
        dbid = kwargs.get('dbid')

        if id is not None:
            return DataSet.objects.get(iric_data_id=id)
        elif dbid is not None:
            return DataSet.objects.get(pk=dbid)

        return None

    def resolve_datafiles(self, info, **kwargs):
        # qs = DataFile.objects.accessible_to_profile(self.request.user.profile)
        qs = DataFile.objects
        key = kwargs.get('key', None)
        value = kwargs.get('value', None)
        dataset = kwargs.get('dataset', None)

        if key and value:
            qs = qs.filter(annotations__contains={key: value})
        elif key:
            qs = qs.filter(annotations__has_key=key)
        elif value:
            qs = qs.filter(annotations__values__icontains=value)

        if dataset:
            qs = qs.filter(datasets__iric_data_id=dataset)

        return qs.distinct()

    def resolve_datasets(self, info, **kwargs):
        return DataSet.objects.all()


class Mutation(graphene.ObjectType):
    pass


schema = graphene.Schema(query=Query, auto_camelcase=False)