Built base things!

Author: Yosef-AlSabbah

.env

@@ -0,0 +1,6 @@
+DB_NAME=eCommerce
+DB_USER=eCommerce
+DB_PASSWORD=0592876798
+DB_HOST=localhost
+REDIS_HOST=localhost
+REDIS_PORT=6379

.gitignore

@@ -1,2 +1,3 @@
 .venv
-.idea
+.idea
+Notes

README.md

@@ -0,0 +1,8 @@
+from rest_framework.pagination import PageNumberPagination
+
+
+class CustomPageNumberPagination(PageNumberPagination):
+    page_size = 10
+    page_size_query_param = 'page_size'
+    max_page_size = 100
+    page_query_param = 'page'

api/Pagination.py

@@ -1,3 +1,34 @@
 from django.contrib import admin
 
-# Register your models here.
+from .models import User, Profile, Category, Product
+
+
+@admin.register(User)
+class UserAdmin(admin.ModelAdmin):
+    list_display = ('username', 'email', 'first_name', 'last_name', 'is_staff', 'is_active')
+    list_filter = ('is_staff', 'is_active', 'date_joined')
+    search_fields = ('username', 'email', 'first_name', 'last_name')
+    ordering = ('date_joined',)
+
+
+@admin.register(Profile)
+class ProfileAdmin(admin.ModelAdmin):
+    list_display = ('user', 'location', 'birth_date')
+    search_fields = ('user__username', 'location')
+    list_filter = ('birth_date',)
+
+
+@admin.register(Category)
+class CategoryAdmin(admin.ModelAdmin):
+    list_display = ('name', 'slug')
+    search_fields = ('name',)
+    prepopulated_fields = {'slug': ('name',)}
+
+
+@admin.register(Product)
+class ProductAdmin(admin.ModelAdmin):
+    list_display = ('name', 'price', 'stock', 'category', 'slug')
+    list_filter = ('category', 'tags', 'price', 'stock')
+    search_fields = ('name', 'description', 'category__name', 'tags__name')
+    prepopulated_fields = {'slug': ('name',)}
+    autocomplete_fields = ('category',)

api/admin.py

@@ -0,0 +1,47 @@
+from django.contrib.postgres.search import TrigramSimilarity
+from django_filters import FilterSet
+from rest_framework.filters import BaseFilterBackend
+
+from api.models import Product
+
+
+class ProductFilter(FilterSet):
+    """
+    FilterSet for Product model.
+    This filter allows filtering products based on various fields such as
+    name, description, price, stock, category, and tags.
+    """
+
+    class Meta:
+        model = Product
+        fields = {
+            'name': ['exact', 'icontains'],
+            'description': ['icontains'],
+            'price': ['exact', 'lt', 'gt', 'range'],
+            'stock': ['exact', 'lt', 'gt'],
+            'category__name': ['exact', 'icontains'],
+            'tags__name': ['exact', 'icontains'],
+        }
+
+
+class InStockFilterBackend(BaseFilterBackend):
+    """
+    Custom filter to only show products that are in stock.
+    """
+
+    def filter_queryset(self, request, queryset, view):
+        return queryset.filter(stock__gt=0)
+
+
+class ProductSearchFilterBackend(BaseFilterBackend):
+    """
+    Custom filter to search products by name and description.
+    """
+
+    def filter_queryset(self, request, queryset, view):
+        search = request.query_params.get('search', None)
+        if search:
+            queryset.annotate(
+                similarity=TrigramSimilarity('name', search),
+            ).filter(similarity__gt=0.1).order_by('-similarity')
+        return queryset

api/filters.py

@@ -19,6 +19,14 @@ class Profile(models.Model):
     birth_date = models.DateField(null=True, blank=True)
     picture = models.ImageField(upload_to=profile_upload_to_unique, null=True, blank=True)
 
+    class Meta:
+        verbose_name = "Profile"
+        verbose_name_plural = "Profiles"
+        indexes = [
+            models.Index(fields=['user']),
+        ]
+        ordering = ['user']
+
     def __str__(self):
         return f'{self.user.username} Profile'
 
@@ -27,8 +35,16 @@ class Category(models.Model):
     name = models.CharField(max_length=255)
     slug = models.SlugField(max_length=255, unique=True)
 
+    class Meta:
+        verbose_name = "Category"
+        verbose_name_plural = "Categories"
+        indexes = [
+            models.Index(fields=['name']),
+        ]
+        ordering = ["name"]
+
     def __str__(self):
-        return self.name
+        return f"Category: {self.name}"
 
 
 class Product(models.Model):
@@ -43,20 +59,90 @@ class Product(models.Model):
         blank=True,
         upload_to=product_upload_to_unique
     )
-
     category = models.ForeignKey(
         Category,
         related_name="products",
         on_delete=models.CASCADE,
-
     )
-
-    objects = models.Manager()
-    tags = TaggableManager
+    tags = TaggableManager()
+
+    class Meta:
+        verbose_name = "Product"
+        verbose_name_plural = "Products"
+        indexes = [
+            models.Index(fields=['slug']),
+            models.Index(fields=['name']),
+            models.Index(fields=['category']),
+        ]
+        ordering = ["name"]
 
     def save(self, *args, **kwargs):
-        self.slug = slugify(self.name)
+        # Auto-generate slug if not set or name changes
+        if not self.slug or self.name != self.__class__.objects.get(pk=self.pk).name:
+            self.slug = slugify(self.name)
         super().save(*args, **kwargs)
 
     def __str__(self):
-        return self.name
+        return f"Product: {self.name} (ID: {self.product_id})"
+
+
+class Order(models.Model):
+    class Status(models.TextChoices):
+        PENDING = 'PE', 'Pending'
+        COMPLETED = 'CO', 'Completed'
+        CANCELLED = 'CA', 'Cancelled'
+
+    user = models.ForeignKey(User, on_delete=models.SET_NULL, null=True)
+    quantity = models.IntegerField()
+    order_date = models.DateTimeField(auto_now_add=True)
+    status = models.CharField(max_length=10, choices=Status.choices, default=Status.PENDING)
+
+    class Meta:
+        verbose_name = "Order"
+        verbose_name_plural = "Orders"
+        indexes = [
+            models.Index(fields=['user']),
+            models.Index(fields=['order_date']),
+        ]
+        ordering = ["-order_date"]
+
+    @property
+    def total_price(self):
+        """
+        Calculate the total price of the order.
+
+        Returns:
+            Decimal: The total price, which is the sum of all order items' prices.
+        """
+        return sum(item.price for item in self.items.all())
+
+    def __str__(self):
+        return f"Order: {self.id} by {self.user.username if self.user else 'Deleted User'}"
+
+
+class OrderItem(models.Model):
+    order = models.ForeignKey(Order, related_name='items', on_delete=models.CASCADE)
+    product = models.ForeignKey(Product, on_delete=models.CASCADE)
+    quantity = models.PositiveSmallIntegerField()
+
+    class Meta:
+        verbose_name = "Order Item"
+        verbose_name_plural = "Order Items"
+        indexes = [
+            models.Index(fields=['order']),
+            models.Index(fields=['product']),
+        ]
+        ordering = ["order"]
+
+    @property
+    def price(self):
+        """
+        Calculate the total price for the order item.
+
+        Returns:
+            Decimal: The total price, which is the product of the item's price and quantity.
+        """
+        return self.product.price * self.quantity
+
+    def __str__(self):
+        return f"Order Item: {self.product.name} (Order ID: {self.order.id})"

api/models.py

@@ -1,6 +1,6 @@
 from rest_framework import serializers
 
-from .models import Category, Product, User, Profile
+from .models import Category, Product, User, Profile, Order, OrderItem
 
 
 class UserSerializer(serializers.ModelSerializer):
@@ -51,8 +51,7 @@ def update(self, instance, validated_data):
         # Custom update method to handle tags
         tags = validated_data.pop('tags', None)  # Extract tags from validated data
         if tags:
-            instance.tags.clear()  # Clear existing tags
-            instance.tags.set(*tags)  # Assign new tags
+            instance.tags.set(*tags)  # Replace existing tags with new ones
         else:
             instance.tags.clear()  # Clear tags if none are provided
 
@@ -71,3 +70,19 @@ class Meta:
             'category',
             'tags'
         ]
+
+
+class OrderSerializer(serializers.ModelSerializer):
+    class OrderItemSerializer(serializers.ModelSerializer):
+        product = ProductSerializer(many=False, read_only=True)
+
+        class Meta:
+            model = OrderItem
+            fields = ['product', 'quantity', 'price']
+
+    order_items = OrderItemSerializer(many=True, read_only=True)
+
+    class Meta:
+        model = Order
+        fields = ['user', 'quantity', 'order_date', 'order_items', 'total_price']
+        read_only_fields = ['user', 'order_date']

api/serializers.py

@@ -0,0 +1,15 @@
+from django.db.models.signals import post_save, post_delete
+from django.dispatch import receiver
+
+from api.models import Category
+
+
+@receiver([post_save, post_delete], sender=Category)
+def invalidate_category_cache(sender, instance, **kwargs):
+    """
+    Invalidate the cache for the category list when a category is created or deleted.
+    """
+    from django.core.cache import cache
+
+    # Clear the cache for the category list
+    cache.delete_pattern('*category_list*')