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(),
            key_values=graphene.JSONString(),
            keys=graphene.JSONString(),
            values=graphene.JSONString(),
            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)
        key_values = kwargs.get('key_values', None)
        keys = kwargs.get('keys', None)
        values = kwargs.get('values', None)
        dataset = kwargs.get('dataset', None)

        if type(key_values) is not dict:
            key_values = {}

        if type(keys) is not list:
            keys = []

        if type(values) is not list:
            values = []

        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)

        for k, v in key_values.items():
            qs = qs.filter(annotations__contains={k: v})

        for k in keys:
            qs = qs.filter(annotations__has_key=k)

        for v in values:
            qs = qs.filter(annotations__values__icontains=v)

        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)