Question

假设我有一个带有两个表的models.py：

class Category(models.Model):
    cat = models.CharField(max_length=100)


class Thing(models.Model):
    desc = models.CharField(max_length=100)
    category = models.ForeignKey(Category, on_delete=models.SET_NULL, null=True, blank=True)

和我的模式如下：

class ThingType(DjangoObjectType):
    class Meta:
        model = Thing


class FindThing(graphene.ObjectType):
    things = graphene.List(
        ThingType,
        search=graphene.String(),
        thing=graphene.ID(),
    )

    def resolve_things(self, info, thing=None, search=None, **kwargs):
        qs = Thing.objects.all()

        if search:
            filter = (
                Q(desc__icontains=search)
            )
            qs = qs.filter(filter)
        if thing:
            qs = qs.filter(id=thing)

        return qs


class CreateThing(graphene.Mutation):
    id = graphene.Int()
    desc = graphene.String()
    category = graphene.Field(FindCategory)

    class Arguments:
        desc = graphene.String()
        category = graphene.Int()

    def mutate(self, info, desc, category):
        thing = Thing(
            desc=desc,
            category=Category.objects.get(id=category)
        )
        thing.save()

        return CreateThing(
            id=thing.id,
            desc=thing.desc,
            category=thing.category_id
        )

class CategoryType(DjangoObjectType):
    class Meta:
        model = Category


class GetCategory(graphene.ObjectType):
    category = graphene.List(
        CategoryType,
        category=graphene.String(),
    )

    def resolve_category(self, info, category=None, **kwargs):
        qs = Category.objects.all()

        if category:
            get = (
                Q(category__contains=category)
            )
            qs = qs.get(get)

        return qs


class FindCategory(graphene.ObjectType):
    categories = graphene.List(
        CategoryType,
        search=graphene.String(),
        cat=graphene.ID(),
    )

    def resolve_categories(self, info, cat=None, search=None, **kwargs):
        qs = Category.objects.all()

        if search:
            filter = (
                Q(cat__icontains=search)
            )
            qs = qs.filter(filter)
        if cat:
            qs = qs.filter(id=cat)

        return qs


class CreateCategory(graphene.Mutation):
    id = graphene.Int()
    cat = graphene.String()
    desc = graphene.String()

    class Arguments:
        cat = graphene.String()
        desc = graphene.String()

    def mutate(self, info, cat, desc):
        category = Category(
            cat=cat
        )
        category.save()
        thing = Thing(
            desc=desc,
            category_id=category.id
        )
        thing.save()

        return CreateCategory(
            id=category.id,
            cat=category.cat,
            desc=thing.desc,
        )

我设法创建了一个架构，在其中可以创建一个已经链接到新创建的单个事物的新类别：

mutation createCategory{
  createCategory(cat:"cat7", desc:"defg"){
    id
    cat
    desc
  }
}

是否可以创建一个CreateCategory django-graphene模式，在其中可以创建包含多个其他新事物的类别？

Answer 1

您可以允许CreateCategory突变接受多种说明的列表：

CreateCategory:
    descs = graphene.List(String)

    class Arguments:
    descs = graphene.List(String)

，然后在mutate函数中遍历此列表：

new_things = []

for desc in descs:
    thing = Thing(
        desc=desc,
        category_id=category.id
    )
    thing.save()
    new_things.append(thing.desc)

return CreateCategory(
    id=category.id,
    cat=category.cat,
    descs=new_things
)

Graphene-Django创建多个实例

1 个答案: