ob-dj-store 0.0.19__py3-none-any.whl → 0.0.23.2__py3-none-any.whl

ob_dj_store/apis/stripe/serializers.py

@@ -0,0 +1,185 @@
+from django.contrib.auth import get_user_model
+from django.utils.translation import gettext_lazy as _
+from rest_framework import serializers
+
+from ob_dj_store.core.stores.gateway.stripe.models import StripeCustomer, StripePayment
+from ob_dj_store.core.stores.gateway.stripe.utils import StripeException
+from ob_dj_store.core.stores.models import Payment, PaymentMethod
+
+User = get_user_model()
+
+
+class StripeCustomerSerializer(serializers.ModelSerializer):
+    """Serializer for Stripe customer information"""
+
+    class Meta:
+        model = StripeCustomer
+        fields = [
+            "stripe_customer_id",
+            "first_name",
+            "last_name",
+            "email",
+            "phone_number",
+            "created_at",
+        ]
+        read_only_fields = ["stripe_customer_id", "created_at"]
+
+
+class StripePaymentSerializer(serializers.ModelSerializer):
+    """Serializer for Stripe payment information"""
+
+    amount = serializers.DecimalField(max_digits=10, decimal_places=3, read_only=True)
+    currency = serializers.CharField(read_only=True)
+    payment_url = serializers.CharField(read_only=True)
+
+    class Meta:
+        model = StripePayment
+        fields = [
+            "payment_intent_id",
+            "client_secret",
+            "status",
+            "source",
+            "amount",
+            "currency",
+            "payment_url",
+            "created_at",
+            "updated_at",
+        ]
+        read_only_fields = [
+            "payment_intent_id",
+            "client_secret",
+            "status",
+            "source",
+            "amount",
+            "currency",
+            "payment_url",
+            "created_at",
+            "updated_at",
+        ]
+
+
+class CreateStripePaymentSerializer(serializers.Serializer):
+    """Serializer for creating Stripe payments"""
+
+    payment_id = serializers.IntegerField(
+        help_text="ID of the Payment object to process with Stripe"
+    )
+    return_url = serializers.URLField(
+        required=False,
+        help_text="URL to redirect to after payment completion (optional)",
+    )
+
+    def validate_payment_id(self, value):
+        """Validate that the payment exists and belongs to the user"""
+        user = self.context["request"].user
+
+        try:
+            payment = Payment.objects.get(id=value, user=user)
+        except Payment.DoesNotExist:
+            raise serializers.ValidationError(
+                _("Payment not found or does not belong to you.")
+            )
+
+        # Check if payment method is Stripe
+        if payment.method.payment_provider != "stripe":
+            raise serializers.ValidationError(_("Payment method must be Stripe."))
+
+        # Check if payment is already processed
+        if hasattr(payment, "stripe_payment"):
+            if payment.stripe_payment.status in ["succeeded", "canceled"]:
+                raise serializers.ValidationError(
+                    _("Payment has already been processed.")
+                )
+
+        return value
+
+    def create(self, validated_data):
+        """Create a Stripe PaymentIntent for the payment"""
+        user = self.context["request"].user
+        payment_id = validated_data["payment_id"]
+        return_url = validated_data.get("return_url")
+
+        payment = Payment.objects.get(id=payment_id, user=user)
+
+        try:
+            # Create or get existing Stripe payment
+            if hasattr(payment, "stripe_payment"):
+                stripe_payment = payment.stripe_payment
+            else:
+                stripe_payment = StripePayment.objects.create(
+                    payment=payment, user=user
+                )
+
+            return {
+                "payment_intent_id": stripe_payment.payment_intent_id,
+                "client_secret": stripe_payment.client_secret,
+                "status": stripe_payment.status,
+                "amount": stripe_payment.amount,
+                "currency": stripe_payment.currency,
+                "return_url": return_url,
+            }
+
+        except StripeException as e:
+            raise serializers.ValidationError({"stripe": str(e)})
+
+
+class StripePaymentStatusSerializer(serializers.Serializer):
+    """Serializer for checking Stripe payment status"""
+
+    payment_intent_id = serializers.CharField(
+        help_text="Stripe PaymentIntent ID to check status for"
+    )
+
+    def validate_payment_intent_id(self, value):
+        """Validate that the payment intent exists and belongs to the user"""
+        user = self.context["request"].user
+
+        try:
+            stripe_payment = StripePayment.objects.get(
+                payment_intent_id=value, user=user
+            )
+        except StripePayment.DoesNotExist:
+            raise serializers.ValidationError(
+                _("Payment intent not found or does not belong to you.")
+            )
+
+        return value
+
+
+class StripeWebhookEventSerializer(serializers.Serializer):
+    """Serializer for processing Stripe webhook events"""
+
+    id = serializers.CharField()
+    type = serializers.CharField()
+    data = serializers.DictField()
+
+    def validate(self, attrs):
+        """Validate webhook event structure"""
+        if "object" not in attrs.get("data", {}):
+            raise serializers.ValidationError(_("Invalid webhook event structure."))
+
+        return attrs
+
+
+class PaymentMethodSerializer(serializers.ModelSerializer):
+    """Serializer for payment methods with Stripe support"""
+
+    supports_stripe = serializers.SerializerMethodField()
+
+    class Meta:
+        model = PaymentMethod
+        fields = [
+            "id",
+            "name",
+            "name_arabic",
+            "description",
+            "description_arabic",
+            "payment_provider",
+            "is_active",
+            "supports_stripe",
+        ]
+        read_only_fields = ["supports_stripe"]
+
+    def get_supports_stripe(self, obj):
+        """Check if this payment method supports Stripe"""
+        return obj.payment_provider == "stripe"

ob_dj_store/apis/stripe/urls.py

@@ -0,0 +1,25 @@
+from django.conf.urls import include
+from django.urls import path
+from rest_framework.routers import SimpleRouter
+
+from ob_dj_store.apis.stripe.views import StripePaymentViewSet, StripeWebhookViewSet
+
+app_name = "stripe_gateway"
+
+router = SimpleRouter(trailing_slash=False)
+
+# Payment management endpoints
+router.register(r"payments", StripePaymentViewSet, basename="stripe-payment")
+
+# Webhook endpoints
+router.register(r"webhook", StripeWebhookViewSet, basename="stripe-webhook")
+
+urlpatterns = [
+    # Direct webhook URL for easier access from Stripe
+    path(
+        "callback/",
+        StripeWebhookViewSet.as_view({"post": "callback"}),
+        name="webhook-callback",
+    ),
+    path("", include(router.urls)),
+]

ob_dj_store/apis/stripe/views.py

@@ -0,0 +1,191 @@
+import logging
+
+from django.http import HttpResponse, HttpResponseBadRequest
+from django.utils.decorators import method_decorator
+from django.views.decorators.csrf import csrf_exempt
+from drf_yasg import openapi
+from drf_yasg.utils import swagger_auto_schema
+from rest_framework import mixins, permissions, status, viewsets
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ob_dj_store.core.stores.gateway.stripe.models import StripePayment
+from ob_dj_store.core.stores.gateway.stripe.utils import (
+    handle_stripe_webhook,
+    verify_webhook_signature,
+)
+
+from .serializers import (
+    CreateStripePaymentSerializer,
+    StripeCustomerSerializer,
+    StripePaymentSerializer,
+    StripePaymentStatusSerializer,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class StripePaymentViewSet(
+    mixins.CreateModelMixin, mixins.RetrieveModelMixin, viewsets.GenericViewSet
+):
+    """Stripe payment management endpoints"""
+
+    permission_classes = [permissions.IsAuthenticated]
+    serializer_class = StripePaymentSerializer
+
+    def get_queryset(self):
+        """Filter stripe payments by current user"""
+        return StripePayment.objects.filter(user=self.request.user)
+
+    def get_serializer_class(self):
+        """Return appropriate serializer class based on action"""
+        if self.action == "create_payment":
+            return CreateStripePaymentSerializer
+        elif self.action == "check_status":
+            return StripePaymentStatusSerializer
+        return self.serializer_class
+
+    @swagger_auto_schema(
+        operation_summary="Create Stripe Payment",
+        operation_description="""
+            Create a Stripe PaymentIntent for an existing Payment object.
+            Returns client_secret for frontend payment confirmation.
+        """,
+        tags=["Stripe Payment"],
+        request_body=CreateStripePaymentSerializer,
+        responses={
+            201: openapi.Response(
+                description="Payment intent created successfully",
+                examples={
+                    "application/json": {
+                        "payment_intent_id": "pi_1234567890",
+                        "client_secret": "pi_1234567890_secret_abc123",
+                        "status": "requires_payment_method",
+                        "amount": "25.00",
+                        "currency": "usd",
+                    }
+                },
+            )
+        },
+    )
+    @action(detail=False, methods=["POST"])
+    def create_payment(self, request):
+        """Create a Stripe PaymentIntent for a payment"""
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+
+        result = serializer.save()
+        return Response(result, status=status.HTTP_201_CREATED)
+
+    @swagger_auto_schema(
+        operation_summary="Check Payment Status",
+        operation_description="""
+            Check the current status of a Stripe payment.
+        """,
+        tags=["Stripe Payment"],
+        request_body=StripePaymentStatusSerializer,
+    )
+    @action(detail=False, methods=["POST"])
+    def check_status(self, request):
+        """Check the status of a Stripe payment"""
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+
+        payment_intent_id = serializer.validated_data["payment_intent_id"]
+
+        try:
+            stripe_payment = StripePayment.objects.get(
+                payment_intent_id=payment_intent_id, user=request.user
+            )
+
+            payment_serializer = StripePaymentSerializer(stripe_payment)
+            return Response(payment_serializer.data)
+
+        except StripePayment.DoesNotExist:
+            return Response(
+                {"error": "Payment not found"}, status=status.HTTP_404_NOT_FOUND
+            )
+
+    @swagger_auto_schema(
+        operation_summary="Get User's Stripe Customer",
+        operation_description="""
+            Get or create Stripe customer information for the current user.
+        """,
+        tags=["Stripe Payment"],
+    )
+    @action(detail=False, methods=["GET"])
+    def customer(self, request):
+        """Get user's Stripe customer information"""
+        try:
+            from ob_dj_store.core.stores.gateway.stripe.utils import (
+                get_or_create_stripe_customer,
+            )
+
+            stripe_customer = get_or_create_stripe_customer(request.user)
+            serializer = StripeCustomerSerializer(stripe_customer)
+            return Response(serializer.data)
+
+        except Exception as e:
+            logger.error(f"Error getting Stripe customer: {e}")
+            return Response(
+                {"error": "Failed to get customer information"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+
+@method_decorator(csrf_exempt, name="dispatch")
+class StripeWebhookViewSet(viewsets.GenericViewSet):
+    """Stripe webhook endpoints"""
+
+    permission_classes = [permissions.AllowAny]
+
+    @swagger_auto_schema(
+        operation_summary="Stripe Webhook Callback",
+        operation_description="""
+            Handle Stripe webhook events for payment status updates.
+            This endpoint is called by Stripe when payment events occur.
+        """,
+        tags=["Stripe Webhook"],
+    )
+    @action(detail=False, methods=["POST"])
+    def callback(self, request):
+        """Handle Stripe webhook callbacks"""
+        logger.info(
+            f"Received webhook request from IP: {request.META.get('REMOTE_ADDR')}"
+        )
+        logger.info(f"Request headers: {dict(request.META)}")
+
+        payload = request.body
+        sig_header = request.META.get("HTTP_STRIPE_SIGNATURE")
+
+        logger.info(f"Payload length: {len(payload)}")
+        logger.info(f"Signature header present: {bool(sig_header)}")
+
+        if not sig_header:
+            logger.warning("Missing Stripe signature header")
+            return HttpResponseBadRequest("Missing signature")
+
+        try:
+            # Verify webhook signature
+            event = verify_webhook_signature(payload, sig_header)
+            logger.info(f"Received Stripe webhook: {event['type']}")
+
+            # Handle the webhook
+            result = handle_stripe_webhook(event)
+
+            if result:
+                logger.info("Webhook processed successfully")
+                return HttpResponse("OK", status=200)
+            else:
+                logger.error("Failed to process webhook")
+                return HttpResponseBadRequest("Failed to process webhook")
+
+        except ValueError as e:
+            logger.error(f"Invalid payload: {e}")
+            return HttpResponseBadRequest("Invalid payload")
+        except Exception as e:
+            logger.error(f"Webhook error: {e}")
+            import traceback
+
+            logger.error(f"Webhook error traceback: {traceback.format_exc()}")
+            return HttpResponseBadRequest(str(e))

ob_dj_store/apis/tap/views.py

@@ -28,9 +28,7 @@ class TapPaymentViewSet(mixins.RetrieveModelMixin, viewsets.GenericViewSet):
         operation_description="""
             gateway_tap callback
         """,
-        tags=[
-            "TAP Payment",
-        ],
+        tags=["TAP Payment",],
     )
     @action(detail=False, methods=["POST"], permission_classes=[permissions.AllowAny])
     def callback(self, request) -> typing.Any:
@@ -55,9 +53,7 @@ class TapPaymentViewSet(mixins.RetrieveModelMixin, viewsets.GenericViewSet):
         operation_description="""
             Retrieve Tap Transaction from charge id
         """,
-        tags=[
-            "TAP Payment",
-        ],
+        tags=["TAP Payment",],
     )
     @action(detail=False, methods=["get"], permission_classes=[permissions.AllowAny])
     def get(self, request, *args, **kwargs):

ob_dj_store/core/stores/admin.py

@@ -3,8 +3,8 @@ from typing import Any
 
 from django import forms
 from django.contrib import admin
-from django.db.models import DecimalField, ExpressionWrapper, F, Sum, Value
-from django.db.models.functions import ExtractWeek, Round
+from django.db.models import DecimalField, F, Sum, Value
+from django.db.models.functions import Coalesce, ExtractWeek
 from django.utils.translation import gettext_lazy as _
 from import_export.admin import ImportExportModelAdmin
 from leaflet.admin import LeafletGeoAdmin
@@ -24,6 +24,7 @@ from ob_dj_store.core.stores.admin_inlines import (
     ProductAttributeInlineAdmin,
     ProductMediaInlineAdmin,
     ProductVariantInlineAdmin,
+    TipAmountInlineAdmin,
 )
 
 
@@ -84,6 +85,8 @@ class StoreAdmin(LeafletGeoAdmin):
         "minimum_order_amount",
         "delivery_charges",
         "min_free_delivery_amount",
+        "created_at",
+        "updated_at",
     ]
     # define the pickup addresses field as a ManyToManyField
     # to the address model
@@ -110,7 +113,7 @@ class StoreAdmin(LeafletGeoAdmin):
                     "pickup_addresses",
                     "image",
                     "currency",
-                    "is_open_after_midnight",
+                    "timezone",
                 )
             },
         ),
@@ -140,16 +143,10 @@ class CategoryAdmin(admin.ModelAdmin):
     ]
 
     def get_queryset(self, request):
-        return (
-            super()
-            .get_queryset(request)
-            .prefetch_related(
-                "availability_hours",
-            )
-        )
+        return super().get_queryset(request).prefetch_related("availability_hours",)
 
 
-class ProductVariantAdmin(admin.ModelAdmin):
+class ProductVariantAdmin(ImportExportModelAdmin, admin.ModelAdmin):
     inlines = [
         InventoryInlineAdmin,
         ProductAttributeInlineAdmin,
@@ -214,13 +211,7 @@ class ProductAdmin(admin.ModelAdmin):
         return [category.name for category in obj.category.all()]
 
     def get_queryset(self, request):
-        return (
-            super()
-            .get_queryset(request)
-            .prefetch_related(
-                "category",
-            )
-        )
+        return super().get_queryset(request).prefetch_related("category",)
 
 
 class ProductAttributeAdmin(admin.ModelAdmin):
@@ -286,25 +277,19 @@ class CartAdmin(admin.ModelAdmin):
     search_fields = [
         "customer__email",
     ]
+    autocomplete_fields = ["customer"]
 
     def get_queryset(self, request):
         queryset = super().get_queryset(request)
         queryset = queryset.annotate(
-            calculated_total_price=Round(
+            calculated_total_price=Coalesce(
                 Sum(
-                    ExpressionWrapper(
-                        (
-                            F("items__product_variant__inventories__price")
-                            - F("items__product_variant__inventories__price")
-                            * F("items__product_variant__inventories__discount_percent")
-                            / 100
-                        ),
-                        output_field=DecimalField(),
-                    )
-                    * F("items__quantity"),
-                    default=Value(0),
+                    F("items__quantity")
+                    * F("items__product_variant__inventories__price"),
                     output_field=DecimalField(),
-                )
+                ),
+                Value(0),
+                output_field=DecimalField(),
             )
         )
         return queryset
@@ -312,7 +297,9 @@ class CartAdmin(admin.ModelAdmin):
     def calculated_total_price(self, obj):
         return obj.calculated_total_price
 
-    calculated_total_price.admin_order_field = "calculated_total_price"
+    calculated_total_price.admin_order_field = (
+        "calculated_total_price"  # Allow sorting by total_price
+    )
     calculated_total_price.short_description = "Price"
 
 
@@ -383,17 +370,13 @@ class OrderAdmin(ImportExportModelAdmin, admin.ModelAdmin):
         "status",
         WeekNumberFilter,  # Include the filter instance instead of the class name
     ]
+    autocomplete_fields = ["customer"]
 
     def get_queryset(self, request):
         queryset = (
             super()
             .get_queryset(request)
-            .select_related(
-                "shipping_method",
-                "payment_method",
-                "store",
-                "customer",
-            )
+            .select_related("shipping_method", "payment_method", "store", "customer",)
             .prefetch_related(
                 "items",
                 "items__product_variant__inventories",
@@ -422,6 +405,7 @@ class PaymentAdmin(ImportExportModelAdmin, admin.ModelAdmin):
     search_fields = ["orders__store__name", "user__email"]
     readonly_fields = ("orders",)
     date_hierarchy = "created_at"
+    autocomplete_fields = ["user"]
 
 
 class InventoryAdmin(admin.ModelAdmin):
@@ -532,6 +516,7 @@ class PartnerAdmin(admin.ModelAdmin):
     inlines = [
         PartnerEmailDomainInlineAdmin,
     ]
+    ordering = ["created_at"]
 
 
 class DiscountAdmin(admin.ModelAdmin):
@@ -551,6 +536,23 @@ class PartnerAuthInfoAdmin(admin.ModelAdmin):
     list_filter = ["authentication_expires", "partner"]
 
 
+class TipAdmin(admin.ModelAdmin):
+    list_display = (
+        "id",
+        "name",
+        "description",
+        "is_active",
+        "country",
+    )
+    search_fields = [
+        "name",
+    ]
+    list_filter = ("country",)
+    inlines = [
+        TipAmountInlineAdmin,
+    ]
+
+
 admin.site.register(models.Store, StoreAdmin)
 admin.site.register(models.ShippingMethod, ShippingMethodAdmin)
 admin.site.register(models.PaymentMethod, PaymentMethodAdmin)
@@ -575,3 +577,4 @@ admin.site.register(models.Partner, PartnerAdmin)
 admin.site.register(models.Discount, DiscountAdmin)
 admin.site.register(models.PartnerAuthInfo, PartnerAuthInfoAdmin)
 admin.site.register(models.CountryPaymentMethod, CountryPaymentMethodAdmin)
+admin.site.register(models.Tip, TipAdmin)

ob_dj_store/core/stores/admin_inlines.py

@@ -13,6 +13,7 @@ class OpeningHoursInlineAdmin(admin.TabularInline):
         "from_hour",
         "to_hour",
         "always_open",
+        "is_open_after_midnight",
     ]
 
     def get_queryset(self, request):
@@ -26,13 +27,7 @@ class AvailabilityHoursInlineAdmin(admin.TabularInline):
     fields = ["store", "weekday", "from_hour", "to_hour"]
 
     def get_queryset(self, request):
-        return (
-            super()
-            .get_queryset(request)
-            .select_related(
-                "store",
-            )
-        )
+        return super().get_queryset(request).select_related("store",)
 
 
 class PhoneContactInlineAdmin(admin.TabularInline):
@@ -107,12 +102,7 @@ class CartItemInlineAdmin(admin.TabularInline):
 class OrderItemInline(admin.TabularInline):
     model = models.OrderItem
     extra = 0
-    fields = (
-        "product_variant",
-        "quantity",
-        "unit_value",
-        "total_amount",
-    )
+    fields = ("product_variant", "quantity", "unit_value", "total_amount", "notes")
     readonly_fields = (
         "unit_value",
         "total_amount",
@@ -130,3 +120,8 @@ class InventoryOperationInlineAdmin(admin.TabularInline):
 class PartnerEmailDomainInlineAdmin(admin.TabularInline):
     model = models.PartnerEmailDomain
     extra = 1
+
+
+class TipAmountInlineAdmin(admin.TabularInline):
+    model = models.TipAmount
+    extra = 0

ob_dj_store/core/stores/gateway/stripe/__init__.py

@@ -0,0 +1,2 @@
+# Stripe Payment Gateway
+default_app_config = "ob_dj_store.core.stores.gateway.stripe.apps.StripeConfig"