Can you include Django REST framework?

[ardamutlu]

i am using Django REST framework. I stored token to databse but token return null

https://imgur.com/a/s8PdM ` from django.conf import settings from graphene import relay, AbstractType, Mutation, Node from graphql_relay.node.node import from_global_id import graphene from graphene_django.filter import DjangoFilterConnectionField from graphene_django import DjangoObjectType import django_filters import logging from django.db import models from django.utils.http import urlsafe_base64_decode as uid_decoder from django.utils.encoding import force_text

from django.conf import settings
from django.db.models.signals import post_save
from django.dispatch import receiver
from rest_framework.authtoken.models import Token
from django.contrib.auth.models import User
from rest_framework import authentication
from rest_framework import exceptions

from rest_framework.settings import api_settings
from musclemesh.kullanici.settings import graph_auth_settings

import django.contrib.auth
# from django.contrib.auth.tokens import default_token_generator as token_generator
# from django.utils.encoding import force_bytes
# from django.utils.http import urlsafe_base64_encode

UserModel = User

class DynamicUsernameMeta(type):
    def __new__(mcs, classname, bases, dictionary):
        dictionary[UserModel.USERNAME_FIELD] = graphene.String(required=True)
        return type.__new__(mcs, classname, bases, dictionary)

class UserNode(DjangoObjectType):
    class Meta:
        model = UserModel
        interfaces = (relay.Node, )
        only_fields = graph_auth_settings.USER_FIELDS
        filter_fields = graph_auth_settings.USER_FIELDS

    token = graphene.String()
    @classmethod
    def get_node(cls, id, context, info):
        user = super(UserNode, cls).get_node(id, context, info)
        if context.user.id and (user.id == context.user.id or context.user.is_staff):
            return user
        else:
            return None

    def resolve_token(self, args, context, info):
        if self.id != context.user.id and not getattr(self, 'is_current_user', False):
            return None

    @receiver(post_save, sender=settings.AUTH_USER_MODEL)
    def create_auth_token(sender, instance=None, created=False, **kwargs):
        if created:
            token = Token.objects.create(user=instance)
        return token
        # jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
        # jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER

        # payload = jwt_payload_handler(self)
        # token = jwt_encode_handler(payload)

        # return token

class RegisterUser(relay.ClientIDMutation):
    class Input(metaclass=DynamicUsernameMeta):
        username = graphene.String(required=True)
        email = graphene.String()
        password = graphene.String()

    ok = graphene.Boolean()
    user = graphene.Field(UserNode)

    @classmethod
    def mutate_and_get_payload(cls, input, context, info):
        model = UserModel
        if graph_auth_settings.ONLY_ADMIN_REGISTRATION and not (context.user.id and context.user.is_staff):
            return RegisterUser(ok=False, user=None)
        if 'clientMutationId' in input:
            input.pop('clientMutationId')
        email = input.pop('email')
        username = input.pop(UserModel.USERNAME_FIELD, email)
        password = input.pop('password') if 'password' in input else model.objects.make_random_password()

        user = model.objects.create_user(username, email, password, **input)
        user.is_current_user = True

        if graph_auth_settings.WELCOME_EMAIL_TEMPLATE is not None and graph_auth_settings.EMAIL_FROM is not None:
            from mail_templated import EmailMessage
            input_data = user.__dict__
            input_data['password'] = password
            message = EmailMessage(graph_auth_settings.WELCOME_EMAIL_TEMPLATE, input_data, graph_auth_settings.EMAIL_FROM, [user.email])
            message.send()

        return RegisterUser(ok=True, user=user)

# =============================================================
class LoginUser(relay.ClientIDMutation):
    class Input(metaclass=DynamicUsernameMeta):
        username = graphene.String(required=True)
        password = graphene.String(required=True)

    ok = graphene.Boolean()
    user = graphene.Field(UserNode)

    @classmethod
    def mutate_and_get_payload(cls, input, context, info):
        model = UserModel

        params = {
            model.USERNAME_FIELD: input.get(model.USERNAME_FIELD, ''),
            'password': input.get('password')
        }

        user = django.contrib.auth.authenticate(**params)

        if user:
            user.is_current_user = True
            return LoginUser(ok=True, user=user)
        else:
            return LoginUser(ok=False, user=None)


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

    me = graphene.Field(UserNode)
    def resolve_me(self, args, context, info):
        return UserNode.get_node(context.user.id, context, info)

class Mutation(AbstractType):
    register_user = RegisterUser.Field()
    login_user = LoginUser.Field()

`

[morgante]

Can you explain what the bug is here and what you're looking to accomplish? It sounds like you maybe what a pluggable token generation method?