django-rest-framework | 🎸 | REST library

class Category(models.Model):
    title = models.CharField(max_length=50, unique=True)
    slug = models.SlugField(max_length=80, default='')

    def __str__(self):
        return self.title

class Option(models.Model):
    title = models.CharField(max_length=80)
    slug = models.SlugField(max_length=80, unique=True)
    description = models.CharField(max_length=250)
    price = models.DecimalField(max_digits=7,  decimal_places=2)
    category = models.ForeignKey(Category, related_name='options', on_delete=models.CASCADE)
    photo = models.ImageField(upload_to='options', null=True)

    class Meta:
        ordering = ['title']
    
    def __str__(self):
        return self.title

class CategorySerializer(serializers.HyperlinkedModelSerializer):
    options = serializers.HyperlinkedRelatedField(many=True, view_name='option-detail', read_only=True)
    class Meta:
        model = Category
        fields = ('url', 'slug', 'title', 'options')
        lookup_field = 'slug'
        extra_kwargs = {
            'url': {'lookup_field': 'slug'}
        }

class OptionSerializer(serializers.HyperlinkedModelSerializer):
    category = serializers.ReadOnlyField(source='category.title')
    class Meta:
        model = Option
        fields = ('url', 'slug', 'title', 'description', 'price', 'category')
        lookup_field = 'slug'
        extra_kwargs = {
            'url': {'lookup_field': 'slug'},
            'category': {'lookup_field': 'slug'}
        }

class CategoryViewSet(viewsets.ReadOnlyModelViewSet):
    """
    Returns the Category list or the requested one
    """
    queryset = Category.objects.all()
    serializer_class = CategorySerializer
    lookup_field = 'slug'

class OptionViewSet(viewsets.ReadOnlyModelViewSet):
    """
    Returns the Option list or the requested one
    """
    queryset = Option.objects.all()
    serializer_class = OptionSerializer
    lookup_field = 'slug'

router = DefaultRouter()
router.register(r'options', views.OptionViewSet)
router.register(r'categories', views.CategoryViewSet)

urlpatterns = [
    path('', include(router.urls)),
]

class IdSerializer(serializers.Serializer):
    id = serializers.IntegerField(required=None)

class MyView(APIView):
    serializer_class = PostIdSerializer

    def post(self, request):
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            post_id = serializer.validated_data.get("id")
        return Response()

{
    "id": [
        "This field is required."
    ]
}

class Product(models.Model):
    name = models.CharField(max_length=150)
    price = models.IntegerField()
    slug = models.SlugField(blank=True, null=True)

    def __str__(self):
        return self.name

    def save(self, *args, **kwargs):
        self.slug = slugify(self.name)
        super(Product, self).save()

class ProductStock(models.Model):
    product = models.ForeignKey(Product, on_delete=models.CASCADE)
    size = models.CharField(max_length=6)
    quantity = models.IntegerField(default=0)

    def __str__(self):
        return f'{self.quantity} x {self.product.name}: {self.size}'

class CartItem(models.Model):
    user = models.ForeignKey(CustomUser, on_delete=models.CASCADE)
    product = models.ForeignKey(ProductStock, on_delete=models.CASCADE, blank=True, null=True)
    amount = models.IntegerField(default=0, blank=True, null=True)
    size = models.CharField(max_length=10, blank=True, null=True)
    price = models.IntegerField(blank=True, null=True)

    def __str__(self):
        return f'{self.user.email}, {self.product.product.name}, {self.product.size}: {self.amount}'
    
    def save(self, *args, **kwargs):
        if self.amount > self.product.quantity:
            self.amount = self.product.quantity
        self.size = self.product.size
        self.price = self.product.product.price
        super(CartItem, self).save()

def check_cart_content(request,user_id):
    cart = CartItem.objects.filter(user=user_id)

    for item in cart:
        product_stock = ProductStock.objects.filter(product=item.product.id)
        for stock in product_stock:
            if item.amount > stock.quantity:
                item.amount = stock.quantity

            product = Product.objects.get(id=item.product.id)
            if item.price != product.price:
                item.price = product.price

            item.save()

            return JsonResponse({'success': 'Cart checked'})

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework_simplejwt.authentication.JWTAuthentication',
    ],
    'DEFAULT_SCHEMA_CLASS': 'rest_framework.schemas.coreapi.AutoSchema',
}

{
    "detail": "Authentication credentials were not provided."
}

@api_view(['POST'])
@permission_classes([AllowAny]) 
def reset_password_request(email):
    try:
    #...

urlpatterns = [
    path('user/<str:pk>/', views.getUserById, name='user'),
    path('user/password_reset_request/',
         views.resetPasswordRequest, name='password_reset_request'),
]

class FavoriteViewSet(APIView):
    def get(self, request, recipe_id):
        user = request.user.id
        data = {"user": user, "recipe": recipe_id}
        serializer = FavoriteSerializer(
            data=data,
            context={"request": request},
        )
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(serializer.data, status.HTTP_201_CREATED)

    def delete(self, request, recipe_id):
        user = request.user
        favorite_recipe = get_object_or_404(
            Favorite, user=user, recipe__id=recipe_id
        )
        favorite_recipe.delete()
        return Response(
            "Рецепт удален из избранного", status.HTTP_204_NO_CONTENT
        )


class PurchaseListView(APIView):
    def get(self, request, recipe_id):
        user = request.user.id
        data = {"user": user, "recipe": recipe_id}
        serializer = PurchaseListSerializer(
            data=data, context={"request": request}
        )
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(serializer.data, status.HTTP_201_CREATED)

    def delete(self, request, recipe_id):
        user = request.user
        purchase_list_recipe = get_object_or_404(
            PurchaseList, user=user, recipe__id=recipe_id
        )
        purchase_list_recipe.delete()
        return Response(
            "Рецепт удален из списка покупок", status.HTTP_204_NO_CONTENT
        )

class GoogleLogin(SocialLoginView):
    adapter_class = GoogleOAuth2Adapter
    callback_url = "http://localhost:3000"
    client_class = OAuth2Client

path('google-login/', GoogleLogin.as_view(), name='google-login'),

const googleLogin = async (accesstoken,code) => {
    console.log(accesstoken)
    let res = await cacaDB.post(

      `google-login/`,
      {
        access_token: accesstoken,
        code: code 
      }
    );
    console.log(res);
    return await res.status;
};


const responseGoogle = (response) => {
    console.log(response.code);
    googleLogin(response.accessToken, response.code);

    }
return(
<div className="App">
                <h1>LOGIN WITH GOOGLE</h1>
      
                <GoogleLogin
                clientId="client_id"
                buttonText="LOGIN WITH GOOGLE"
                onSuccess={responseGoogle}
                onFailure={responseGoogle}
                />
            </div>
)

class Meta:
    indexes = [
        models.Index(fields=['-current']),
        models.Index(fields=['current']),
    ]

current = models.IntegerField(null=True)

  companies/migrations/0294_auto_20220110_1155.py
    - Create index companies_c_current_f2c815_idx on field(s) -current of model company
    - Create index companies_c_current_c8bcb7_idx on field(s) current of model company

# explain analyze select * from company order by current desc nulls last limit 100;
                                            

    QUERY PLAN                                                                       
--------------------------------------------------------------------------------------------------------------------------------------------------------
 Limit  (cost=41028.75..41040.42 rows=100 width=1223) (actual time=866.587..867.650 rows=100 loops=1)   ->  Gather Merge  (cost=41028.75..68747.19 rows=237570 width=1223) (actual time=866.585..867.644 rows=100 loops=1)
         Workers Planned: 2
         Workers Launched: 2
         ->  Sort  (cost=40028.73..40325.69 rows=118785 width=1223) (actual time=849.292..849.296 rows=48 loops=3)
               Sort Key: current DESC NULLS LAST
               Sort Method: top-N heapsort  Memory: 275kB
               Worker 0:  Sort Method: top-N heapsort  Memory: 314kB
               Worker 1:  Sort Method: top-N heapsort  Memory: 299kB
               ->  Parallel Seq Scan on companies_company  (cost=0.00..35488.85 rows=118785 width=1223) (actual time=0.278..756.498 rows=95028 loops=3)
 Planning Time: 0.444 ms
 Execution Time: 867.759 ms
(12 rows)


# explain analyze select * from company order by current asc nulls last limit 100;
                                                         

    QUERY PLAN                                                                                    
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Limit  (cost=0.42..49.79 rows=100 width=1223) (actual time=1.700..13.268 rows=100 loops=1)
   ->  Index Scan Backward using companies_c_current_f2c815_idx on companies_company  (cost=0.42..140727.06 rows=285084 width=1223) (actual time=1.698..13.244 rows=100 loops=1)
 Planning Time: 1.139 ms
 Execution Time: 13.426 ms
(4 rows)

@api_view(['GET','POST'])
def myMethod(request):

   from rest_framework.response import Response

   if request.method == 'POST':
       import gzip
       # ****Some code lines here to generated small json***
       myJson = json.dumps(parsed, indent=4)
       compressedContent = gzip.compress(myJson.encode('utf-8'), 5)  # compressedContent is byte format
       return Response(compressedContent, status=status.HTTP_200_OK)

def get_num_modelA(self, o):
    r = ModelA.objects.filter(modelB__modelC__order=o).count()

    return r

@staticmethod
def setup_eager_loading(queryset):
    # select_related for "to-one" relationships
    queryset = queryset.select_related('modelD','modelE')
    
    return queryset