ob-dj-store 0.0.21.4__py3-none-any.whl → 0.0.21.6__py3-none-any.whl

ob_dj_store/apis/stores/rest/serializers/serializers.py

@@ -529,9 +529,15 @@ class OrderSerializer(serializers.ModelSerializer):
         return super().validate(attrs)
 
     def perform_payment(self, amount, payment_method, order_store, orders, currency):
+        from django.conf import settings
+
+        from ob_dj_store.core.stores.gateway.stripe.utils import StripeException
         from ob_dj_store.core.stores.gateway.tap.utils import TapException
 
         user = self.context["request"].user
+        payment_transaction = None
+        charge_id = None
+
         try:
             payment = Payment.objects.create(
                 user=user,
@@ -540,21 +546,40 @@ class OrderSerializer(serializers.ModelSerializer):
                 currency=currency,
                 orders=orders,
             )
-            tap_transaction = payment.tap_payment
+
+            # Handle different payment gateways
+            if payment_method and payment_method.payment_provider == settings.STRIPE:
+                payment_transaction = payment.stripe_payment
+                charge_id = (
+                    payment_transaction.payment_intent_id
+                    if payment_transaction
+                    else None
+                )
+            elif payment_method and payment_method.payment_provider in [
+                settings.TAP_CREDIT_CARD,
+                settings.TAP_KNET,
+                settings.TAP_ALL,
+                settings.MADA,
+                settings.BENEFIT,
+            ]:
+                payment_transaction = payment.tap_payment
+                charge_id = (
+                    payment_transaction.charge_id if payment_transaction else None
+                )
+
         except ValidationError as err:
             raise serializers.ValidationError(detail=err.messages)
-        except TapException as err:
-            raise serializers.ValidationError({"tap": _(str(err))})
+        except (TapException, StripeException) as err:
+            raise serializers.ValidationError({"payment_gateway": _(str(err))})
         except ObjectDoesNotExist as err:
             logger.info(
                 f"Payment Object not created: user:{user}, method:{payment_method}, currency:{currency}, error:{err}"
             )
-            tap_transaction = None
 
         return {
             "orders": orders,
             "payment_url": payment.payment_url,
-            "charge_id": tap_transaction.charge_id if tap_transaction else None,
+            "charge_id": charge_id,
         }
 
     def create(self, validated_data: typing.Dict):
@@ -1654,6 +1679,7 @@ class WalletTopUpSerializer(serializers.Serializer):
                 store_settings.GOOGLE_PAY,
                 store_settings.MADA,
                 store_settings.BENEFIT,
+                store_settings.STRIPE,
             ]
         ),
         required=True,

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/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"

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

@@ -0,0 +1,77 @@
+"""
+Stripe Payment Gateway Admin
+
+This module contains the admin configuration for Stripe payment models.
+"""
+
+from django.contrib import admin
+from import_export.admin import ImportExportModelAdmin
+
+from ob_dj_store.core.stores.gateway.stripe.models import StripeCustomer, StripePayment
+
+
+@admin.register(StripePayment)
+class StripePaymentAdmin(ImportExportModelAdmin):
+    list_display = (
+        "payment_intent_id",
+        "payment",
+        "user",
+        "status",
+        "amount",
+        "currency",
+        "source",
+        "created_at",
+    )
+    list_filter = ("status", "source", "created_at")
+    search_fields = ("payment_intent_id", "user__email", "payment__id")
+    readonly_fields = (
+        "payment_intent_id",
+        "client_secret",
+        "init_response",
+        "webhook_response",
+        "created_at",
+        "updated_at",
+    )
+    raw_id_fields = ("payment", "user")
+    date_hierarchy = "created_at"
+
+    def get_queryset(self, request):
+        return (
+            super()
+            .get_queryset(request)
+            .select_related("payment__payment_tax", "user")
+            .prefetch_related(
+                "payment__orders__items", "payment__orders__shipping_method"
+            )
+        )
+
+    def amount(self, obj):
+        """Display payment amount"""
+        return f"${obj.amount:.2f}"
+
+    amount.short_description = "Amount"
+
+    def currency(self, obj):
+        """Display payment currency"""
+        return obj.currency.upper()
+
+    currency.short_description = "Currency"
+
+
+@admin.register(StripeCustomer)
+class StripeCustomerAdmin(ImportExportModelAdmin):
+    list_display = (
+        "stripe_customer_id",
+        "email",
+        "first_name",
+        "last_name",
+        "customer",
+        "created_at",
+    )
+    search_fields = ("stripe_customer_id", "email", "first_name", "last_name")
+    readonly_fields = ("stripe_customer_id", "init_data", "created_at", "updated_at")
+    raw_id_fields = ("customer",)
+    date_hierarchy = "created_at"
+
+    def get_queryset(self, request):
+        return super().get_queryset(request).select_related("customer")

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

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class StripeConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "ob_dj_store.core.stores.gateway.stripe"
+    verbose_name = _("Gateway: Stripe")
+    label = "stripe"

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

@@ -0,0 +1,35 @@
+"""
+Stripe Payment Gateway Managers
+
+This module contains the managers for Stripe payment models.
+"""
+
+import logging
+
+from django.db import models
+
+from ob_dj_store.core.stores.gateway.stripe import utils
+
+logger = logging.getLogger(__name__)
+
+
+class StripePaymentManager(models.Manager):
+    """Manager for Stripe payments"""
+
+    def create(self, **kwargs):
+        """Create Stripe payment and initiate PaymentIntent"""
+        user = kwargs.get("user")
+        payment = kwargs.get("payment")
+
+        if not user or not payment:
+            raise ValueError("User and payment are required")
+
+        # Initiate Stripe payment
+        stripe_response = utils.initiate_stripe_payment(
+            user=user, payment=payment, currency_code=payment.currency
+        )
+
+        # Merge Stripe response with kwargs
+        kwargs.update(stripe_response)
+
+        return super().create(**kwargs)

ob_dj_store/core/stores/gateway/stripe/migrations/0001_initial.py

@@ -0,0 +1,168 @@
+# Generated by Django 3.2.8 on 2025-08-06 09:07
+
+import django.db.models.deletion
+import phonenumber_field.modelfields
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("stores", "0109_wallettransaction_cashback_type"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="StripePayment",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "payment_intent_id",
+                    models.CharField(
+                        db_index=True,
+                        help_text="Stripe PaymentIntent ID",
+                        max_length=250,
+                        unique=True,
+                    ),
+                ),
+                (
+                    "client_secret",
+                    models.CharField(
+                        help_text="Client secret for frontend confirmation",
+                        max_length=250,
+                    ),
+                ),
+                (
+                    "status",
+                    models.CharField(
+                        choices=[
+                            ("requires_payment_method", "Requires Payment Method"),
+                            ("requires_confirmation", "Requires Confirmation"),
+                            ("requires_action", "Requires Action"),
+                            ("processing", "Processing"),
+                            ("requires_capture", "Requires Capture"),
+                            ("canceled", "Canceled"),
+                            ("succeeded", "Succeeded"),
+                        ],
+                        default="requires_payment_method",
+                        max_length=50,
+                    ),
+                ),
+                (
+                    "source",
+                    models.CharField(
+                        choices=[
+                            ("card", "Credit/Debit Card"),
+                            ("apple_pay", "Apple Pay"),
+                            ("google_pay", "Google Pay"),
+                            ("ach_debit", "ACH Bank Transfer"),
+                            ("klarna", "Klarna"),
+                            ("afterpay_clearpay", "Afterpay"),
+                        ],
+                        default="card",
+                        max_length=50,
+                    ),
+                ),
+                (
+                    "init_response",
+                    models.JSONField(
+                        blank=True,
+                        help_text="Initial PaymentIntent response from Stripe",
+                        null=True,
+                    ),
+                ),
+                (
+                    "webhook_response",
+                    models.JSONField(
+                        blank=True,
+                        help_text="Final webhook response from Stripe",
+                        null=True,
+                    ),
+                ),
+                (
+                    "langid",
+                    models.CharField(
+                        default="EN", help_text="Language preference", max_length=10
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "payment",
+                    models.OneToOneField(
+                        help_text="Reference to local payment transaction",
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="stripe_payment",
+                        to="stores.payment",
+                    ),
+                ),
+                (
+                    "user",
+                    models.ForeignKey(
+                        help_text="User who initiated the payment",
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Stripe Payment",
+                "verbose_name_plural": "Stripe Payments",
+                "ordering": ["-created_at"],
+            },
+        ),
+        migrations.CreateModel(
+            name="StripeCustomer",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "stripe_customer_id",
+                    models.CharField(db_index=True, max_length=200, unique=True),
+                ),
+                ("first_name", models.CharField(max_length=200)),
+                ("last_name", models.CharField(max_length=200)),
+                ("email", models.EmailField(max_length=254, null=True, unique=True)),
+                (
+                    "phone_number",
+                    phonenumber_field.modelfields.PhoneNumberField(
+                        max_length=128, null=True, region=None, unique=True
+                    ),
+                ),
+                ("init_data", models.JSONField()),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "customer",
+                    models.OneToOneField(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="stripe_customer",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Stripe Customer",
+                "verbose_name_plural": "Stripe Customers",
+            },
+        ),
+    ]

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

@@ -0,0 +1 @@
+# Migrations for Stripe payment gateway

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

@@ -0,0 +1,174 @@
+"""
+Stripe Payment Gateway Models
+
+This module contains the models for Stripe payment integration,
+mirroring the structure of the TAP payment gateway.
+"""
+
+import logging
+
+from django.conf import settings
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from phonenumber_field.modelfields import PhoneNumberField
+
+from ob_dj_store.core.stores.gateway.stripe.managers import StripePaymentManager
+
+logger = logging.getLogger(__name__)
+
+
+class StripePayment(models.Model):
+    """StripePayment captures the payment from Stripe"""
+
+    class Status(models.TextChoices):
+        REQUIRES_PAYMENT_METHOD = (
+            "requires_payment_method",
+            _("Requires Payment Method"),
+        )
+        REQUIRES_CONFIRMATION = "requires_confirmation", _("Requires Confirmation")
+        REQUIRES_ACTION = "requires_action", _("Requires Action")
+        PROCESSING = "processing", _("Processing")
+        REQUIRES_CAPTURE = "requires_capture", _("Requires Capture")
+        CANCELED = "canceled", _("Canceled")
+        SUCCEEDED = "succeeded", _("Succeeded")
+
+    class Sources(models.TextChoices):
+        CARD = "card", _("Credit/Debit Card")
+        APPLE_PAY = "apple_pay", _("Apple Pay")
+        GOOGLE_PAY = "google_pay", _("Google Pay")
+        ACH_DEBIT = "ach_debit", _("ACH Bank Transfer")
+        KLARNA = "klarna", _("Klarna")
+        AFTERPAY = "afterpay_clearpay", _("Afterpay")
+
+    # Core fields
+    payment = models.OneToOneField(
+        "stores.Payment",
+        on_delete=models.CASCADE,
+        related_name="stripe_payment",
+        help_text=_("Reference to local payment transaction"),
+    )
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        help_text=_("User who initiated the payment"),
+    )
+
+    # Stripe specific fields
+    payment_intent_id = models.CharField(
+        max_length=250,
+        unique=True,
+        db_index=True,
+        help_text=_("Stripe PaymentIntent ID"),
+    )
+    client_secret = models.CharField(
+        max_length=250, help_text=_("Client secret for frontend confirmation")
+    )
+    status = models.CharField(
+        max_length=50, choices=Status.choices, default=Status.REQUIRES_PAYMENT_METHOD
+    )
+    source = models.CharField(
+        max_length=50, choices=Sources.choices, default=Sources.CARD
+    )
+
+    # Response data
+    init_response = models.JSONField(
+        help_text=_("Initial PaymentIntent response from Stripe"), null=True, blank=True
+    )
+    webhook_response = models.JSONField(
+        help_text=_("Final webhook response from Stripe"), null=True, blank=True
+    )
+
+    # Metadata
+    langid = models.CharField(
+        max_length=10, default="EN", help_text=_("Language preference")
+    )
+
+    # Audit fields
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    objects = StripePaymentManager()
+
+    class Meta:
+        verbose_name = _("Stripe Payment")
+        verbose_name_plural = _("Stripe Payments")
+        ordering = ["-created_at"]
+
+    def __str__(self):
+        return f"StripePayment {self.payment_intent_id}"
+
+    @property
+    def amount(self):
+        """Return payment amount in dollars"""
+        return self.payment.total_payment
+
+    @property
+    def amount_cents(self):
+        """Return payment amount in cents for Stripe"""
+        return int(self.amount * 100)
+
+    @property
+    def currency(self):
+        """Get currency from payment"""
+        return self.payment.currency.lower()
+
+    @property
+    def payment_url(self):
+        """Return client secret for frontend processing"""
+        return self.client_secret
+
+    def webhook_update(self, stripe_event):
+        """Update payment based on Stripe webhook"""
+        payment_intent = stripe_event["data"]["object"]
+
+        # Update status and webhook response
+        old_status = self.status
+        self.status = payment_intent["status"]
+        self.webhook_response = payment_intent
+        self.save()
+
+        # Mark transaction based on new status
+        self.mark_transaction()
+
+        logger.info(
+            f"Stripe webhook updated PaymentIntent {self.payment_intent_id}: {old_status} -> {self.status}"
+        )
+
+    def mark_transaction(self):
+        """Mark the associated payment based on Stripe status"""
+        if self.status == self.Status.SUCCEEDED:
+            self.payment.mark_paid()
+        elif self.status in [self.Status.CANCELED]:
+            error_message = self.webhook_response.get("last_payment_error", {}).get(
+                "message", "Payment failed"
+            )
+            self.payment.mark_failed(error_message)
+
+
+class StripeCustomer(models.Model):
+    """Stripe customer mapping"""
+
+    customer = models.OneToOneField(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name="stripe_customer",
+    )
+    stripe_customer_id = models.CharField(max_length=200, unique=True, db_index=True)
+    first_name = models.CharField(max_length=200)
+    last_name = models.CharField(max_length=200)
+    email = models.EmailField(unique=True, null=True)
+    phone_number = PhoneNumberField(unique=True, null=True)
+
+    # Store original Stripe response
+    init_data = models.JSONField()
+
+    # Audit fields
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        verbose_name = _("Stripe Customer")
+        verbose_name_plural = _("Stripe Customers")
+
+    def __str__(self):
+        return f"{self.email} | {self.stripe_customer_id}"

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

@@ -0,0 +1,170 @@
+"""
+Stripe Payment Gateway Utilities
+
+This module contains utility functions for Stripe payment integration.
+"""
+
+import logging
+
+import stripe
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from django.core.exceptions import ObjectDoesNotExist, ValidationError
+
+User = get_user_model()
+logger = logging.getLogger(__name__)
+
+# Configure Stripe
+stripe.api_key = settings.STRIPE_SECRET_KEY
+stripe.api_version = settings.STRIPE_API_VERSION
+
+
+class StripeException(Exception):
+    """Custom exception for Stripe-related errors"""
+
+
+def get_or_create_stripe_customer(user):
+    """Get or create a Stripe customer for the user"""
+    from ob_dj_store.core.stores.gateway.stripe.models import StripeCustomer
+
+    try:
+        return StripeCustomer.objects.get(customer=user)
+    except ObjectDoesNotExist:
+        pass
+
+    # Create customer in Stripe
+    try:
+        customer_data = {
+            "name": f"{user.first_name} {user.last_name}".strip(),
+            "email": user.email,
+            "metadata": {"user_id": str(user.id), "platform": "ob-dj-store"},
+        }
+
+        # Add phone if available
+        phone_number = getattr(user, "phone_number", None)
+        if phone_number:
+            customer_data["phone"] = str(phone_number)
+
+        stripe_customer = stripe.Customer.create(**customer_data)
+
+        # Save to database
+        customer_record = StripeCustomer.objects.create(
+            customer=user,
+            stripe_customer_id=stripe_customer.id,
+            first_name=user.first_name,
+            last_name=user.last_name,
+            email=user.email,
+            phone_number=phone_number,
+            init_data=stripe_customer,
+        )
+
+        logger.info(f"Created Stripe customer {stripe_customer.id} for user {user.id}")
+        return customer_record
+
+    except stripe.error.StripeError as e:
+        logger.error(f"Failed to create Stripe customer: {str(e)}")
+        raise StripeException(f"Failed to create customer: {str(e)}")
+
+
+def initiate_stripe_payment(user, payment, currency_code):
+    """Initiate a Stripe PaymentIntent"""
+
+    try:
+        # Get or create Stripe customer
+        stripe_customer = get_or_create_stripe_customer(user)
+
+        # Get the first order for metadata
+        order = payment.orders.first()
+
+        # Prepare PaymentIntent data
+        intent_data = {
+            "amount": int(payment.total_payment * 100),  # Convert to cents
+            "currency": currency_code.lower(),
+            "customer": stripe_customer.stripe_customer_id,
+            "metadata": {
+                "payment_id": str(payment.id),
+                "user_id": str(user.id),
+                "order_id": str(order.id) if order else None,
+                "platform": "ob-dj-store",
+            },
+            "automatic_payment_methods": {"enabled": True,},
+        }
+
+        # Add description
+        if order:
+            intent_data[
+                "description"
+            ] = f"Order #{order.id} from {order.store.name if order.store else 'Store'}"
+
+        # Create PaymentIntent
+        payment_intent = stripe.PaymentIntent.create(**intent_data)
+
+        logger.info(
+            f"Created Stripe PaymentIntent {payment_intent.id} for payment {payment.id}"
+        )
+
+        return {
+            "payment_intent_id": payment_intent.id,
+            "client_secret": payment_intent.client_secret,
+            "status": payment_intent.status,
+            "init_response": payment_intent,
+        }
+
+    except stripe.error.StripeError as e:
+        logger.error(f"Failed to create PaymentIntent: {str(e)}")
+        raise StripeException(f"Failed to initiate payment: {str(e)}")
+
+
+def handle_stripe_webhook(event_data):
+    """Handle Stripe webhook events"""
+    from ob_dj_store.core.stores.gateway.stripe.models import StripePayment
+
+    event_type = event_data.get("type")
+
+    # List of payment_intent events we handle
+    payment_intent_events = [
+        "payment_intent.succeeded",
+        "payment_intent.payment_failed",
+        "payment_intent.canceled",
+        "payment_intent.requires_action",
+        "payment_intent.processing",
+    ]
+
+    if event_type in payment_intent_events:
+        payment_intent = event_data["data"]["object"]
+        payment_intent_id = payment_intent["id"]
+
+        try:
+            stripe_payment = StripePayment.objects.get(
+                payment_intent_id=payment_intent_id
+            )
+            stripe_payment.webhook_update(event_data)
+            logger.info(
+                f"Successfully processed {event_type} for PaymentIntent {payment_intent_id}"
+            )
+            return True
+        except ObjectDoesNotExist:
+            logger.warning(
+                f"Received webhook for unknown PaymentIntent: {payment_intent_id}"
+            )
+            # Return True for unknown payments to acknowledge webhook (don't retry)
+            return True
+
+    # Log unhandled events but return True (acknowledged)
+    logger.info(f"Unhandled Stripe webhook event: {event_type}")
+    return True
+
+
+def verify_webhook_signature(payload, signature):
+    """Verify Stripe webhook signature and return event data"""
+    try:
+        event = stripe.Webhook.construct_event(
+            payload, signature, settings.STRIPE_WEBHOOK_SECRET
+        )
+        return event
+    except ValueError:
+        logger.error("Invalid webhook payload")
+        raise ValidationError("Invalid payload")
+    except stripe.error.SignatureVerificationError:
+        logger.error("Invalid webhook signature")
+        raise ValidationError("Invalid signature")

ob_dj_store/core/stores/models/_payment.py

@@ -180,4 +180,8 @@ class Payment(models.Model):
             settings.BENEFIT,
         ]:
             payment_url = self.tap_payment.payment_url
+        elif gateway == settings.STRIPE:
+            # For Stripe, return the client_secret which is used by Stripe.js
+            if hasattr(self, "stripe_payment"):
+                payment_url = self.stripe_payment.payment_url
         return payment_url

ob_dj_store/core/stores/models/_product.py

@@ -250,10 +250,16 @@ class Product(DjangoModelCleanMixin, models.Model):
 
     def get_inventory(self, store_id):
         try:
-            inventory = self.product_variants.first().inventories.get(store_id=store_id)
+            # Prefer the primary variant if available
+            product_variant = (
+                self.product_variants.filter(inventories__is_primary=True).first()
+                or self.product_variants.first()
+            )
+            if not product_variant:
+                return None
+            return product_variant.inventories.get(store_id=store_id)
         except ObjectDoesNotExist:
             return None
-        return inventory
 
     def is_snoozed(self, store_id):
         try:

{ob_dj_store-0.0.21.4.dist-info → ob_dj_store-0.0.21.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ob-dj-store
-Version: 0.0.21.4
+Version: 0.0.21.6
 Summary: OBytes django application for managing ecommerce stores.
 Home-page: https://www.obytes.com/
 Author: OBytes

{ob_dj_store-0.0.21.4.dist-info → ob_dj_store-0.0.21.6.dist-info}/RECORD

@@ -3,7 +3,11 @@ ob_dj_store/apis/stores/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 ob_dj_store/apis/stores/filters.py,sha256=JeUtcicJ3cFnZc71aUMEwn2jaVj1oNQsZOCZfdxGDu8,10338
 ob_dj_store/apis/stores/urls.py,sha256=W9sNJ7ST9pGnfVCf7GmduDO-_zK9MGTI6ybV8n-lzSc,2111
 ob_dj_store/apis/stores/views.py,sha256=cwDFNY2rtTfjl_F9PpR5zOJy2DPmGidOjIlJ9fsgSYI,42744
-ob_dj_store/apis/stores/rest/serializers/serializers.py,sha256=R_FGdD98iLWsb0dsI-kdq9_60yPkwahT_kMpfNPUzmQ,68239
+ob_dj_store/apis/stores/rest/serializers/serializers.py,sha256=rJ3oWg0GqbZ8OoPWRTxcuPkIRYPQPfK4TH4UH4vsjns,69192
+ob_dj_store/apis/stripe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ob_dj_store/apis/stripe/serializers.py,sha256=SX3yKVNbDvE5LL35DF9XoC8sjwGkCSdKz_JUVWsJDLg,5949
+ob_dj_store/apis/stripe/urls.py,sha256=IHH9sX3d74KDUlXkYnIAwYRC6zEvUaOTSFsJGJfiAjA,723
+ob_dj_store/apis/stripe/views.py,sha256=RnGfp77M2AwoEhmkIUPNY7xoiH0MODMUNF7e9uvt12g,6913
 ob_dj_store/apis/tap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ob_dj_store/apis/tap/serializers.py,sha256=KPrBK4h2-fWvEVf6vOj2ww5-USV9WqpyYicIqoHIiXI,1065
 ob_dj_store/apis/tap/urls.py,sha256=bnOTv6an11kxpo_FdqlhsizlGPLVpNxBjCyKcf3_C9M,367
@@ -18,6 +22,14 @@ ob_dj_store/core/stores/receivers.py,sha256=vduxOB9M6IgQ8E7dYrbC4T0PjOqLCgAVi2Pw
 ob_dj_store/core/stores/settings_validation.py,sha256=eTkRaI6CG5OEJQyI5CF-cNAcvjzXf3GwX5sR97O3v98,3977
 ob_dj_store/core/stores/utils.py,sha256=r6YdjQu5gsrZmO_qgXb21xcB50tbAI9vffN4Yp6n6iA,3427
 ob_dj_store/core/stores/gateway/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ob_dj_store/core/stores/gateway/stripe/__init__.py,sha256=Plk4Ur6tDpc7Cz2YdgDtu6Y6yHUZR2Vpxsq9bysoZ8g,105
+ob_dj_store/core/stores/gateway/stripe/admin.py,sha256=gQ4orM5Hm0LquKP38XeCsm4vLRSGQr6KO-hEe_uNVHY,2119
+ob_dj_store/core/stores/gateway/stripe/apps.py,sha256=UYt5Kj_bi1Y-lAPVi_8eJbyiINESy_Os-UqOX2UT4GI,292
+ob_dj_store/core/stores/gateway/stripe/managers.py,sha256=tEU3NlKWz9Vv8MJrkugeHUo8Zk-ThG0q993Rjr_0kCw,895
+ob_dj_store/core/stores/gateway/stripe/models.py,sha256=-A_Inq6NsFengz4zv7mBDt6P9BP_XS7jN6pBnZ97GqM,5597
+ob_dj_store/core/stores/gateway/stripe/utils.py,sha256=u3nU2UQbgxkbrjIe6OiuB6zseiFhXXX0lP4Cx0ofpWU,5581
+ob_dj_store/core/stores/gateway/stripe/migrations/0001_initial.py,sha256=dlzfmrt3zyFJHMUxSt8QADl-TkpHVRgvfbl8GPyy6Ws,6274
+ob_dj_store/core/stores/gateway/stripe/migrations/__init__.py,sha256=-hjs2JUX2zw379yapyaYFiunRtwtqeYnBkiiQS9HA3o,40
 ob_dj_store/core/stores/gateway/tap/__init__.py,sha256=5Z6azpb6tmr1nRvKwQWzlYw9ruvw-9ZMBWRqEngDKTM,40
 ob_dj_store/core/stores/gateway/tap/admin.py,sha256=tGtLg6ttkZXb7JtFPD-5r46pCmb1BsbQpv182KlY3-o,1153
 ob_dj_store/core/stores/gateway/tap/apps.py,sha256=kWwPjuAJeEmEasVDzUbvRsGaQWL-aYe4JDHNLvCVXPs,212
@@ -152,15 +164,15 @@ ob_dj_store/core/stores/models/_feedback.py,sha256=5kQ_AD9nkY57UOKo_qHg4_nEQAdFj
 ob_dj_store/core/stores/models/_inventory.py,sha256=_rGlVL5HjOlHQVB8CI0776CPcE5r6szv1w3PjtkYnWM,4306
 ob_dj_store/core/stores/models/_order.py,sha256=_08lqX5p4brCdUilqfbT--6Ao2TMsqnzXaWoV_7IYL8,9758
 ob_dj_store/core/stores/models/_partner.py,sha256=OuYvevUWn1sYHs9PcFf51EUUC1uqytQss8Bx91aMOH8,4732
-ob_dj_store/core/stores/models/_payment.py,sha256=FTV-NmvQjxwwR5C5X7qYWV-ZUIZfqMMEjkBNaS-drLs,6421
-ob_dj_store/core/stores/models/_product.py,sha256=cYMsCtcYoJJ-kdmDmHGm2AGBo2cn6qWuF9g7zQJ_p2g,18283
+ob_dj_store/core/stores/models/_payment.py,sha256=SfAMVrdP2Hfz604AyO8EOjeiOgGMeJ8My0s5U4GZ7Yc,6650
+ob_dj_store/core/stores/models/_product.py,sha256=KUi2hkA4VNCrWwWp3AM_tkubFptpOdiFt0Twzi2wW14,18535
 ob_dj_store/core/stores/models/_store.py,sha256=0K-CNJWuXNqeyULL1J0M9hiNcVla0UNNjdCdN_nzNEE,9833
 ob_dj_store/core/stores/models/_wallet.py,sha256=YvT-rvED-jrYjePLJpvdLXXoBudR6TGPu5cNE0m2fWo,5643
 ob_dj_store/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ob_dj_store/utils/helpers.py,sha256=o7wgypM7mI2vZqZKkhxnTcnHJC8GMQDOuYMnRwXr6tY,2058
 ob_dj_store/utils/model.py,sha256=DV7hOhTaZL3gh9sptts2jTUFlTArKG3i7oPioq9HLFE,303
 ob_dj_store/utils/utils.py,sha256=8UVAFB56qUSjJJ5f9vnermtw638gdFy4CFRCuMbns_M,1342
-ob_dj_store-0.0.21.4.dist-info/METADATA,sha256=qhdG-tlBDz4MV9ybB8VQwDWe5t-2eKMTacinZNLizjo,2850
-ob_dj_store-0.0.21.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ob_dj_store-0.0.21.4.dist-info/top_level.txt,sha256=CZG3G0ptTkzGnc0dFYN-ZD7YKdJBmm47bsmGwofD_lk,12
-ob_dj_store-0.0.21.4.dist-info/RECORD,,
+ob_dj_store-0.0.21.6.dist-info/METADATA,sha256=suIPKWs6v3NePNuNpqbqF57ezgAuw3p34iphhABaMfI,2850
+ob_dj_store-0.0.21.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ob_dj_store-0.0.21.6.dist-info/top_level.txt,sha256=CZG3G0ptTkzGnc0dFYN-ZD7YKdJBmm47bsmGwofD_lk,12
+ob_dj_store-0.0.21.6.dist-info/RECORD,,