+Category graphQL

store_back/apps/authAPI/admin.py

@@ -0,0 +1,6 @@
+from django.contrib import admin
+from .models import CustomUser
+
+@admin.register(CustomUser)
+class CustomUserAdmin(admin.ModelAdmin):
+    pass

store_back/apps/categories/schema.py

@@ -0,0 +1,170 @@
+import graphene
+from graphene_django.types import DjangoObjectType
+from .models import Category
+import json
+from functools import reduce
+from .serializers import CategorySerializer
+import operator
+from django.db.models import Q
+import goods.schema as  good_schema
+from django.forms.models import model_to_dict
+
+
+
+
+class CategoryType(DjangoObjectType):
+    _id = graphene.String(name='_id')
+    name = graphene.String()
+    parent = graphene.Field(lambda: CategoryType)
+    goods = graphene.List(good_schema.GoodType)
+
+    class Meta:
+        model = Category
+        exclude_fields = ('_id',"name","parent","goods")
+
+    def resolve__id(self,info):
+        return self._id
+
+    def resolve_goods(self,info):
+        try:
+            iter(self.goods)
+            return self.goods
+        except:
+            return self.goods.all()
+
+
+    def resolve_parent(self,info):
+        return self.parent
+
+
+
+class CategoryInput(graphene.InputObjectType):
+    _id = graphene.String(name='_id')
+    name = graphene.String()
+    parent = graphene.Field(lambda:CategoryInput)
+    goods = graphene.List(good_schema.GoodInput)
+
+
+
+class Query(graphene.ObjectType):
+    CategoryFind = graphene.List(CategoryType,query = graphene.String())
+    CategoryFindOne = graphene.Field(CategoryType,query = graphene.String())
+
+
+    def resolve_CategoryFind(self,info,query = "[{}]"):
+        additional_params = {}
+        query_list = json.loads(query)
+        filter_params = query_list[0]
+        if len(query_list) > 1:
+            additional_params = query_list[1]
+
+        skip = additional_params.get("skip",0)
+        limit = additional_params.get("limit",20)
+        order_by = additional_params.get("orderBy","_id")
+
+        query_set = Category.objects.all()
+
+        if len(filter_params):
+            query_set = query_set.filter(reduce(operator.and_,(Q(**d) for d in [dict([i]) for i in filter_params.items()])))
+
+
+        return query_set
+
+
+    def resolve_CategoryFindOne(self,info,query = "[{}]"):
+        additional_params = {}
+        query_list = json.loads(query)
+        filter_params = query_list[0]
+        if len(query_list) > 1:
+            additional_params = query_list[1]
+
+        skip = additional_params.get("skip",0)
+        limit = additional_params.get("limit",20)
+        order_by = additional_params.get("orderBy","_id")
+
+        query_set = Category.objects.all()
+
+        if len(filter_params):
+            query_set = query_set.filter(reduce(operator.and_,(Q(**d) for d in [dict([i]) for i in filter_params.items()])))
+
+        return query_set.first()
+
+
+
+
+class CategoryUpsert(graphene.Mutation):
+
+    class Arguments:
+        category = CategoryInput(required=True)
+
+    Output =CategoryType
+
+    @staticmethod
+    def mutate(root,info,category ={}):
+        new_category={}
+        good_list = []
+
+        if "goods" in category:
+            good_list = [f['_id'] for f in category["goods"]]
+            category.pop("goods",None)
+
+
+        try:
+            _id = category._id
+            new_category = Category.objects.get(_id = _id)
+            new_category.__dict__.update(**category)
+        except Exception as e:
+
+            new_category = Category(**category)
+
+        new_category.save()
+        if len(good_list):
+            new_category.goods.set(good_list)
+        category_data = model_to_dict(new_category)
+        category_data["_id"] = new_category._id
+        print(category_data)
+        return CategoryType(**category_data)
+
+
+
+
+class CategoryDelete(graphene.Mutation):
+
+    class Arguments:
+        category =  CategoryInput(required=True)
+
+    Output =CategoryType
+
+    @staticmethod
+    def mutate(root,info,category):
+        # user = info.context.user
+        # if not user.is_superuser:
+        #     raise Exception("Authentication credentials were not provided")
+
+
+        try:
+            _id = category._id
+            category_to_delete = Category.objects.get(_id=_id)
+            category_data = CategorySerializer(category_to_delete).data
+            category_to_delete.delete()
+
+        except:
+            raise Exception("Не вірні дані")
+
+
+
+        return CategoryType(**category_data)
+
+
+
+
+
+
+
+class Mutations(graphene.ObjectType):
+
+    CategoryUpsert = CategoryUpsert.Field()
+    CategoryDelete = CategoryDelete.Field()
+
+
+

store_back/apps/categories/serializers.py

@@ -10,17 +10,18 @@ class SubCategorySerializer(serializers.ModelSerializer):
         fields = ['_id','name']
 
 class CategorySerializer(serializers.ModelSerializer):
-    parent = SubCategorySerializer()
-    subcategories =SubCategorySerializer(many=True)
-    goods = serializers.SerializerMethodField()
+    goods = GoodSerializer(many=True)
 
-    def get_goods(self, instance):
-        goods = instance.goods.all().order_by(self.context.get("goods_order_by","_id"))
-        return GoodSerializer(goods, many=True).data
 
     class Meta:
         model =  Category
         fields = ['_id','name','parent','subcategories','goods']
+        depth = 1
 
 
+    def get_fields(self):
+        fields = super(CategorySerializer, self).get_fields()
+        fields['subcategories'] = CategorySerializer(many=True)
+        fields['parent'] = CategorySerializer()
+        return fields
 

store_back/apps/goods/schema.py

@@ -5,10 +5,13 @@ from .models import Good,Image
 import json
 from functools import reduce
 from .serializers import GoodSerializer
+from django.forms.models import model_to_dict
+
 import operator
 from django.db.models import Q
 
 
+
 class ImageType(DjangoObjectType):
     _id = graphene.String(name='_id')
     class Meta:
@@ -30,6 +33,7 @@ class GoodType(DjangoObjectType):
     description = graphene.String()
     price = graphene.Int()
     amount = graphene.Int()
+    categories = graphene.List('categories.schema.CategoryType')
 
     class Meta:
         model = Good
@@ -41,6 +45,9 @@ class GoodType(DjangoObjectType):
     def resolve_images(self,info):
         return self.images.all()
 
+    def resolve_categories(self,info):
+        return self.categories.all()
+
     def resolve_name(self,info):
         return self.name
 
@@ -61,6 +68,7 @@ class GoodInput(graphene.InputObjectType):
     description = graphene.String()
     price = graphene.Int()
     amount = graphene.Int()
+    categories = graphene.List('categories.schema.CategoryInput')
 
 
 
@@ -80,8 +88,8 @@ class Query(graphene.ObjectType):
         if len(query_list) > 1:
             additional_params = query_list[1]
 
-        skip = additional_params.get("skip",0)
-        limit = additional_params.get("limit",20)
+        skip = int(additional_params.get("skip",0))
+        limit = int(additional_params.get("limit",20))
         order_by = additional_params.get("orderBy","_id")
 
         query_set = Good.objects.all()
@@ -90,7 +98,7 @@ class Query(graphene.ObjectType):
         if len(filter_params):
             query_set = query_set.filter(reduce(operator.and_,(Q(**d) for d in [dict([i]) for i in filter_params.items()])))
 
-
+        query_set = query_set.order_by(order_by)[skip:skip+limit]
         return query_set
 
 
@@ -164,23 +172,32 @@ class GoodUpsert(graphene.Mutation):
 
     @staticmethod
     def mutate(root,info,good):
+        new_good={}
+        image_list = []
         # user = info.context.user
         # if not user.is_superuser:
         #     raise Exception("Authentication credentials were not provided")
+        if "images" in good:
+            image_list = [f['_id'] for f in good["images"]]
+            good.pop("images",None)
+
 
 
-        new_good={}
         try:
             _id = good._id
             new_good = Good.objects.get(_id = _id)
             good.pop("_id",None)
             new_good.__dict__.update(**good)
-            new_good.save()
         except Exception as e:
             new_good = Good(**good)
-            new_good.save()
-            print(GoodSerializer(new_good).data)
-        return GoodType(**GoodSerializer(new_good).data)
+
+        new_good.save()
+        if len(image_list):
+            new_good.images.set(image_list)
+
+        good_data = model_to_dict(new_good)
+        good_data["_id"] = new_good._id
+        return GoodType(**good_data)
 
 
 

store_back/apps/goods/serializers.py

@@ -11,7 +11,7 @@ class SubCategorySerializer(serializers.ModelSerializer):
 
 
 class ImageSerializer(serializers.ModelSerializer):
-    
+
     class Meta:
         model =  Image
         fields = ['_id','url']
@@ -24,5 +24,6 @@ class GoodSerializer(serializers.ModelSerializer):
     class Meta:
         model =  Good
         fields = ['_id',"name","price","amount","description","images","categories"]
+        depth = 1
 
 

store_back/apps/goods/views.py

@@ -45,6 +45,7 @@ def good_detail(request,_id):
 
     if good:
         serializer = GoodSerializer(good)
+
         return JsonResponse({"data":serializer.data}, safe=False)
     else:
         return JsonResponse({"data":{}}, safe=False)

store_back/schema.py

@@ -1,16 +1,18 @@
 import graphene
 from goods.schema import Query as good_query
+from categories.schema import Query as category_query
 from goods.schema import Mutations as good_mutations
+from categories.schema import Mutations as category_mutations
 
 import graphql_jwt
 
 
-class Mutation(good_mutations):
+class Mutation(good_mutations,category_mutations):
     token_auth = graphql_jwt.ObtainJSONWebToken.Field()
     verify_token = graphql_jwt.Verify.Field()
 
 
-class Query(good_query):
+class Query(good_query,category_query):
     pass
 
 

store_back/utils.py

@@ -5,12 +5,8 @@ from store_back.settings import GRAPHQL_JWT
 ## JWT payload for Hasura
 def jwt_payload(user, context=None):
     token = {}
-    jwt_datetime = datetime.utcnow() + jwt_settings.JWT_EXPIRATION_DELTA
-    jwt_expires = int(jwt_datetime.timestamp())
-    token['username'] = str(user.username) # For library compatibility
-    token['exp'] = jwt_expires
 
-    token['iat'] = datetime.timestamp(datetime.now())
+    token['iat'] =str(datetime.timestamp(datetime.now()))
     token["sub"] = {
         "acl":["anon"],
     }