graphene-django

user_management.models.py

from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin
from django.db import models
from django.utils.translation import ugettext_lazy as _

from .managers import UserManager


class User(AbstractBaseUser, PermissionsMixin):
    """
        User model, extends `django.contrib.auth.models.AbstractBaseUser`
    """
    email = models.EmailField(_('email address'),
                              unique=True)
    name = models.CharField(_('name'),
                            max_length=30,
                            blank=True)
    date_joined = models.DateTimeField(_('date joined'),
                                       auto_now_add=True)
    is_active = models.BooleanField(_('active'),
                                    default=True)
    avatar = models.ImageField(upload_to='avatars/',
                               null=True,
                               blank=True)
    is_superuser = models.BooleanField(default=False)
    is_staff = models.BooleanField(default=False)

    objects = UserManager()

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = []

    def save(self, *args, **kwargs):
        self.full_clean()
        super().save(*args, **kwargs)

user_management.schema.py

import logging

from django.contrib.auth import get_user_model
import graphene
from graphene import relay
from graphene_django import DjangoObjectType
from graphene_django.filter import DjangoFilterConnectionField
import graphql_jwt

from .models import User

logger = logging.getLogger(__name__)


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


class CreateUser(graphene.Mutation):
    user = graphene.Field(UserType)

    class Arguments:
        name = graphene.String(required=True)
        password = graphene.String(required=True)
        email = graphene.String(required=True)

    def mutate(self, info, name, password, email, **kwargs):
        user = get_user_model()(
            name=name,
            email=email,
        )
        user.set_password(password)
        # validation happens inside the model
        user.save()

        return CreateUser(user=user)


class Mutation(graphene.ObjectType):
    create_user = CreateUser.Field()
    token_auth = graphql_jwt.ObtainJSONWebToken.Field()
    verify_token = graphql_jwt.Verify.Field()
    refresh_token = graphql_jwt.Refresh.Field()


class UserNode(DjangoObjectType):
    class Meta:
        model = User
        only_fields = ('name', 'email', 'is_superuser')
        filter_fields = {
            'name': ['exact', 'icontains', 'istartswith'],
            'email': ['exact', 'icontains', 'istartswith'],
            'is_superuser': ['exact']
        }
        interfaces = (relay.Node,)


class Query:
    user = relay.Node.Field(UserNode)
    all_users = DjangoFilterConnectionField(UserNode)

    def resolve_all_users(self, info, **kwargs):
        """
            Only allowed for admin users
        """
        if info.context.user.is_superuser:
            return User.objects.all()
        else:
            return User.objects.none()