change in order mdoel

Author: jsuarez-dev

.vscode/settings.json

@@ -0,0 +1,14 @@
+{
+  "sqltools.connections": [
+    {
+      "previewLimit": 50,
+      "server": "postgres",
+      "port": 5432,
+      "driver": "PostgreSQL",
+      "name": "wine_store",
+      "database": "wine_store",
+      "username": "SvuCYfHrKizkDqgiPnEJGDOYXmPRBOgU",
+      "password": "wPKS5SuYFMcABMA7dILvGrrxtgRG4DUELDCcMFxw1ERTZnmMkDXDMVayXHh6dbak"
+    }
+  ]
+}

local.yml

@@ -33,6 +33,8 @@ services:
       - wine_store_local_postgres_data_backups:/backups
     env_file:
       - ./.envs/.local/.postgres
+    ports:
+      - '5432:5432'
 
   docs:
     image: wine_store_local_docs

wine_store/orders/api/serializers.py

@@ -2,14 +2,28 @@
     Order Serializers
 """
 
+import hashlib
+from random import randint
+
+# Utils
+from time import sleep
+
 # Rest Framework
-from rest_framework.serializers import ModelSerializer
+from rest_framework import serializers
+
+# Cart
+from wine_store.cart.api.serializers import CartModelSerializer
+from wine_store.cart.models import CartItem
 
 # Order
-from wine_store.orders.models import OrderDetail
+from wine_store.orders.models import OrderDetail, OrderItem, OrderPayment
+from wine_store.users.api.serializers import UserAddressModelSerializer
 
+# User
+from wine_store.users.models import UserAddress, UserPayment
 
-class OrderSerializer(ModelSerializer):
+
+class OrderModelSerializer(serializers.ModelSerializer):
     """Order serializer."""
 
     class Meta:
@@ -18,3 +32,119 @@ class Meta:
         model = OrderDetail
         fields = "__all__"
         read_only_fields = ["user", "total", "order_status", "created_at", "updated_at"]
+
+
+class OrderItemModelSerializer(serializers.ModelSerializer):
+    """Order item serializer."""
+
+    class Meta:
+        """Meta options."""
+
+        model = OrderItem
+        fields = "__all__"
+        read_only_fields = ["order_detail", "product", "quantity", "price"]
+
+
+class OrderPaymentModelSerializer(serializers.ModelSerializer):
+    """Order payment serializer."""
+
+    class Meta:
+        """Meta options."""
+
+        model = OrderPayment
+        fields = "__all__"
+        read_only_fields = ["order_detail", "total", "payment_method"]
+
+
+class OrderReadModelSerializer(serializers.ModelSerializer):
+    """Order Detail read serializer."""
+
+    user = serializers.StringRelatedField()
+    shipping_address = UserAddressModelSerializer(many=False, read_only=True)
+    payment = OrderPaymentModelSerializer(many=False, read_only=True)
+    items = OrderItemModelSerializer(many=True, read_only=True)
+
+    class Meta:
+        """Meta options."""
+
+        model = OrderDetail
+        fields = "__all__"
+        read_only_fields = ["user", "total", "order_status", "created_at", "updated_at"]
+
+
+class OrderSerializer(serializers.Serializer):
+    """Order serializer."""
+
+    shipping_address = serializers.IntegerField()
+    payment_method = serializers.IntegerField()
+    cart = CartModelSerializer(many=False, write_only=True)
+
+    def validate_shipping_address(self, value):
+        try:
+            user_address = UserAddress.objects.get(id=value)
+            return user_address
+        except UserAddress.DoesNotExist:
+            raise serializers.ValidationError("The user address does not exist")
+
+    def validate_payment_method(self, value):
+        try:
+            user_payment = UserPayment.objects.get(id=value)
+            return user_payment
+        except UserPayment.DoesNotExist:
+            raise serializers.ValidationError("The user payment does not exist")
+
+    def validate(self, data):
+        items = CartItem.objects.filter(cart=data["cart"])
+        if len(items) == 0:
+            raise serializers.ValidationError("The cart is empty")
+        self.context["items"] = items
+        data["total"] = 0
+        data["order_status"] = "PENDING"
+        return data
+
+    def create(self, validated_data):
+        """Create order."""
+        user_payment = validated_data.pop("user_payment")
+        # Create order detail
+        order = OrderDetail.objects.create(**validated_data)
+        # Create order items
+        items = self.context["items"]
+        for item in items:
+            OrderItem.objects.create(
+                order_detail=order,
+                product=item.product,
+                quantity=item.quantity,
+                price=item.price,
+            )
+        # making payment
+        order.total = order.calculate_total()
+        order.save()
+        payment_status, payment_register = self.make_request_payment(user_payment, order.total)
+        OrderPayment.objects.create(
+            order_detail=order,
+            total=order.total,
+            payment_method=user_payment,
+            payment_register=payment_register,
+            payment_status=payment_status,
+        )
+
+        return order
+
+    def update(self, instance, validated_data):
+        """Update order."""
+        pass
+
+    def make_request_payment(self, user_payment, total):
+        """Make request payment.
+        This is a function simulate the interaction with a payment gateway.
+        """
+        sleep(5)
+        success_flag = True if randint(0, 10) < 8 else False
+        if success_flag:
+            sha_payment = hashlib.sha256(
+                f"{user_payment.id}+{user_payment.provider}+{user_payment.payment_method}+{total}".encode()
+            )
+            payment_register = sha_payment.hexdigest()
+            return ("SUCCESS", payment_register)
+        else:
+            return ("FAILED", None)

wine_store/orders/api/views.py

@@ -6,73 +6,45 @@
 import logging
 
 # Rest Framework
-from rest_framework import status
 from rest_framework.mixins import CreateModelMixin, ListModelMixin, RetrieveModelMixin
 from rest_framework.permissions import IsAuthenticated
-from rest_framework.response import Response
 from rest_framework.viewsets import GenericViewSet
 
 # Cart
-from wine_store.cart.models import Cart, CartItem
-from wine_store.orders.api.serializers import OrderSerializer
+from wine_store.cart.models import Cart
+from wine_store.orders.api.serializers import OrderReadModelSerializer, OrderSerializer
 
 # Orders
-from wine_store.orders.models import OrderDetail, OrderItem, OrderPayment
-
-# Users
-from wine_store.users.models import UserPayment
+from wine_store.orders.models import OrderDetail
 
 # Utils
 from wine_store.utils.permissions import IsOwner
 
+# Users
+
+
 logger = logging.getLogger(__name__)
 
 
 class OrderViewSet(ListModelMixin, RetrieveModelMixin, CreateModelMixin, GenericViewSet):
     """Order view set."""
 
-    serializer_class = OrderSerializer
     permission_classes = [IsAuthenticated, IsOwner]
 
+    def get_serializer_class(self):
+        """Return serializer based on action."""
+        if self.action == "retrieve" or self.action == "list":
+            return OrderReadModelSerializer
+        return OrderSerializer
+
     def get_queryset(self):
         """Return orders for current user."""
         orders = OrderDetail.objects.filter(user=self.request.user)
         return orders
 
     def perform_create(self, serializer):
-        """Create a new order."""
-        cart = Cart.objects.get(id=self.request.user.cart.id)
-        if cart.items.count() == 0:
-            return Response(status=status.HTTP_400_BAD_REQUEST)
-
-        order_detail = serializer.save(user=self.request.user, total=cart.total, order_status="processing")
-        # Create order items
-        cart_items = CartItem.objects.filter(cart=cart)
-        total = 0.0
-        for cart_item in cart_items:
-            OrderItem.objects.create(
-                order_detail=order_detail,
-                product=cart_item.product,
-                quantity=cart_item.quantity,
-                price=cart_item.product.price,
-            )
-            total += +float(cart_item.product.price) * float(cart_item.quantity)
-
-        if total != float(cart.total):
-            logger.error("Total of order is not equal to total of cart")
-
-        payment_method_id = self.request.data.get("payment_method_id")
-        payment = UserPayment.objects.get(id=payment_method_id)
-
-        # Create order payment
-        OrderPayment.objects.create(
-            order_detail=order_detail,
-            payment_method=payment,
-            total=total,
-            payment_status="pending",
-            payment_register=f"O-id-{order_detail.id}-{payment.provider}-{payment.payment_method}",
-        )
-        # Delete cart
+        """Create order."""
+        cart = Cart.objects.get(user=self.request.user)
+        serializer.save(user=self.request.user, cart=cart)
         cart.delete()
-        # create new cart
         Cart.objects.create(user=self.request.user)