ob-dj-store 0.0.11.8__tar.gz → 0.0.11.10__tar.gz

{ob-dj-store-0.0.11.8 → ob-dj-store-0.0.11.10}/PKG-INFO

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

{ob-dj-store-0.0.11.8 → ob-dj-store-0.0.11.10}/config/settings.py

@@ -360,3 +360,6 @@ DIFFERENT_STORE_ORDERING = False
 
 THUMBNAIL_MEDIUM_DIMENSIONS = {"width": 500, "height": 300}
 THUMBNAIL_SMALL_DIMENSIONS = {"width": 200, "height": 200}
+
+# Wallet settings
+WALLET_CURRENCIES = ["KWD", "QAR", "SAR", "AED"]

{ob-dj-store-0.0.11.8 → ob-dj-store-0.0.11.10}/ob_dj_store/apis/stores/filters.py

@@ -5,10 +5,12 @@ from django.utils.timezone import now
 from django_filters import rest_framework as filters
 from rest_framework.exceptions import ValidationError
 
+from config import settings as store_settings
 from ob_dj_store.core.stores.models import (
     Category,
     Favorite,
     Order,
+    PaymentMethod,
     Product,
     ProductVariant,
     Store,
@@ -128,6 +130,7 @@ class CategoryFilter(filters.FilterSet):
                         is_active=True,
                     ).distinct(),
                 ),
+                "subcategories__products__images",
             )
             .distinct()
         )
@@ -174,3 +177,25 @@ class FavoriteFilter(filters.FilterSet):
             content_type=content_type,
             object_id__in=products_ids,
         )
+
+
+class PaymentMethodFilter(filters.FilterSet):
+    store = filters.CharFilter(method="by_store")
+    is_digital = filters.BooleanFilter(method="by_digital")
+
+    class Meta:
+        models = PaymentMethod
+
+    def by_store(self, queryset, name, value):
+        return queryset.filter(stores=value)
+
+    def by_digital(self, queryset, name, value):
+        if value:
+            return queryset.filter(
+                payment_provider__in=[
+                    store_settings.TAP_CREDIT_CARD,
+                    store_settings.TAP_KNET,
+                    store_settings.TAP_ALL,
+                ]
+            )
+        return queryset

{ob-dj-store-0.0.11.8 → ob-dj-store-0.0.11.10}/ob_dj_store/apis/stores/rest/serializers/serializers.py

@@ -39,6 +39,7 @@ from ob_dj_store.core.stores.models import (
     ShippingMethod,
     Store,
     Tax,
+    Wallet,
 )
 from ob_dj_store.core.stores.models._inventory import Inventory
 from ob_dj_store.core.stores.utils import distance
@@ -288,7 +289,7 @@ class OrderSerializer(serializers.ModelSerializer):
         if payment_method:
             if payment_method.payment_provider == store_settings.WALLET:
                 try:
-                    wallet = user.wallets.get(country=attrs["store"].address.country)
+                    wallet = user.wallets.get(currency=attrs["store"].currency)
                 except ObjectDoesNotExist:
                     raise serializers.ValidationError(
                         {
@@ -603,7 +604,9 @@ class ProductSerializer(FavoriteMixin, serializers.ModelSerializer):
         return data
 
 
-class ProductListSerializer(ProductSerializer):
+class ProductListSerializer(serializers.ModelSerializer):
+    product_images = ProductMediaSerializer(many=True, source="images")
+
     class Meta:
         model = Product
         fields = (
@@ -974,7 +977,11 @@ class FavoriteSerializer(serializers.ModelSerializer):
             "extras",
             "object_id",
             "object_type",
+            "name",
         )
+        extra_kwargs = {
+            "name": {"required": True},
+        }
 
     def _lookup_validation(self, data):
         content_type = ContentType.objects.get_for_model(type(data["content_object"]))
@@ -1001,6 +1008,7 @@ class FavoriteSerializer(serializers.ModelSerializer):
 
     def validate(self, attrs):
         validated_data = super().validate(attrs)
+        name = validated_data["name"]
         object_type = validated_data["object_type"]
         if object_type not in store_settings.FAVORITE_TYPES and hasattr(
             sys.modules[__name__], object_type
@@ -1035,14 +1043,50 @@ class FavoriteSerializer(serializers.ModelSerializer):
         validated_data = {
             "content_object": object_instance,
             "extras": extras,
+            "name": name,
         }
         self._lookup_validation(validated_data)
         return validated_data
 
     def create(self, validated_data):
-        favorite = Favorite.add_favorite(
-            validated_data["content_object"],
-            self.context["request"].user,
-            validated_data["extras"],
-        )
+        try:
+            favorite = Favorite.add_favorite(
+                content_object=validated_data["content_object"],
+                user=self.context["request"].user,
+                name=validated_data["name"],
+                extras=validated_data["extras"],
+            )
+        except ValidationError as e:
+            raise serializers.ValidationError(detail=e.message_dict)
         return favorite
+
+
+class WalletSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Wallet
+        fields = ["id", "user", "balance", "name", "image", "image_thumbnail_medium"]
+        extra_kwargs = {
+            "user": {"read_only": True},
+            "image_thumbnail_medium": {"read_only": True},
+        }
+
+
+class WalletTopUpSerializer(serializers.Serializer):
+    amount = serializers.DecimalField(
+        max_digits=10, decimal_places=2, min_value=1, required=True
+    )
+    payment_method = serializers.PrimaryKeyRelatedField(
+        queryset=PaymentMethod.objects.filter(
+            payment_provider__in=[
+                store_settings.TAP_CREDIT_CARD,
+                store_settings.TAP_KNET,
+                store_settings.TAP_ALL,
+            ]
+        ),
+        required=True,
+    )
+
+    def top_up_wallet(self, wallet):
+        amount = self.validated_data["amount"]
+        payment_method = self.validated_data["payment_method"]
+        return wallet.top_up_wallet(amount=amount, payment_method=payment_method)

{ob-dj-store-0.0.11.8 → ob-dj-store-0.0.11.10}/ob_dj_store/apis/stores/urls.py

@@ -16,6 +16,7 @@ from ob_dj_store.apis.stores.views import (
     TaxViewSet,
     TransactionsViewSet,
     VariantView,
+    WalletViewSet,
 )
 
 app_name = "stores"
@@ -28,9 +29,6 @@ stores_router.register(r"order", OrderView, basename="order")
 stores_router.register(r"product", ProductView, basename="product")
 stores_router.register(r"variant", VariantView, basename="variant")
 stores_router.register(r"inventory", InventoryView, basename="inventory")
-stores_router.register(
-    r"payment-method", PaymentMethodViewSet, basename="payment-method"
-)
 stores_router.register(
     r"shipping-method", ShippingMethodViewSet, basename="shipping-method"
 )
@@ -40,6 +38,8 @@ router.register(r"transaction", TransactionsViewSet, basename="transaction")
 router.register(r"cart", CartView, basename="cart")
 router.register(r"cart-item", CartItemView, basename="cart-item")
 router.register(r"favorite", FavoriteViewSet, basename="favorite")
+router.register(r"wallet", WalletViewSet, basename="wallet")
+router.register(r"payment-method", PaymentMethodViewSet, basename="payment-method")
 urlpatterns = [
     path(r"", include(router.urls)),
     path(r"", include(stores_router.urls)),

{ob-dj-store-0.0.11.8 → ob-dj-store-0.0.11.10}/ob_dj_store/apis/stores/views.py

@@ -26,6 +26,7 @@ from ob_dj_store.apis.stores.filters import (
     FavoriteFilter,
     InventoryFilter,
     OrderFilter,
+    PaymentMethodFilter,
     ProductFilter,
     StoreFilter,
     VariantFilter,
@@ -47,6 +48,8 @@ from ob_dj_store.apis.stores.rest.serializers.serializers import (
     ShippingMethodSerializer,
     StoreSerializer,
     TaxSerializer,
+    WalletSerializer,
+    WalletTopUpSerializer,
 )
 from ob_dj_store.core.stores.models import (
     Cart,
@@ -62,6 +65,7 @@ from ob_dj_store.core.stores.models import (
     ShippingMethod,
     Store,
     Tax,
+    Wallet,
 )
 from ob_dj_store.core.stores.models._inventory import Inventory
 
@@ -188,29 +192,6 @@ class StoreView(
         serializer = self.get_serializer(page, many=True)
         return self.get_paginated_response(serializer.data)
 
-    @swagger_auto_schema(
-        operation_summary="Add or Remove Store from Favorites",
-        operation_description="""
-            Add or Remove Store from Favorites
-        """,
-        tags=[
-            "Store",
-        ],
-    )
-    @action(
-        detail=True,
-        methods=["GET"],
-        url_path="favorite",
-    )
-    def favorite(self, request, *args, **kwargs):
-        instance = self.get_object()
-        try:
-            Favorite.objects.favorite_for_user(instance, request.user).delete()
-        except Favorite.DoesNotExist:
-            Favorite.add_favorite(instance, request.user)
-        serializer = StoreSerializer(instance=instance, context={"request": request})
-        return Response(serializer.data)
-
     @swagger_auto_schema(
         operation_summary="Retrieve count of store's products",
         operation_description="""
@@ -674,6 +655,9 @@ class CategoryViewSet(
     filterset_class = CategoryFilter
     lookup_value_regex = "[0-9]+"
 
+    def get_queryset(self):
+        return super().get_queryset().prefetch_related("products__images")
+
     def get_object(self):
         store_id = self.request.query_params.get("store", None)
         instance_pk = self.kwargs["pk"]
@@ -699,6 +683,7 @@ class CategoryViewSet(
                     "products",
                     queryset=product_queryset.distinct(),
                 ),
+                "subcategories__products__images",
             ).get(pk=instance_pk)
         except Category.DoesNotExist:
             raise Http404("No Category matches the given query.")
@@ -800,14 +785,9 @@ class PaymentMethodViewSet(
     permission_classes = [
         permissions.IsAuthenticated,
     ]
-    queryset = PaymentMethod.objects.all()
-
-    def get_queryset(self):
-        try:
-            store = Store.objects.get(pk=self.kwargs["store_pk"])
-        except ObjectDoesNotExist:
-            raise ValidationError(_(f"Store does not Exist"))
-        return store.payment_methods.filter(is_active=True)
+    queryset = PaymentMethod.objects.filter(is_active=True)
+    filterset_class = PaymentMethodFilter
+    lookup_value_regex = "[0-9]+"
 
     @swagger_auto_schema(
         operation_summary="List Payment Methods",
@@ -949,3 +929,84 @@ class FavoriteViewSet(
     )
     def destroy(self, request, *args, **kwargs):
         return super().destroy(request, *args, **kwargs)
+
+
+class WalletViewSet(
+    mixins.ListModelMixin,
+    mixins.RetrieveModelMixin,
+    mixins.UpdateModelMixin,
+    viewsets.GenericViewSet,
+):
+    queryset = Wallet.objects.all()
+    serializer_class = WalletSerializer
+    permission_classes = [
+        permissions.IsAuthenticated,
+    ]
+
+    def get_queryset(self):
+        return Wallet.objects.filter(user=self.request.user)
+
+    @swagger_auto_schema(
+        operation_summary="Get User Wallet",
+        operation_description="""
+                Get User Wallet
+            """,
+        tags=[
+            "Wallet",
+        ],
+    )
+    def retrieve(
+        self, request: Request, *args: typing.Any, **kwargs: typing.Any
+    ) -> Response:
+        return super().retrieve(request=request, *args, **kwargs)
+
+    @swagger_auto_schema(
+        operation_summary="Update user wallet",
+        operation_description="""
+            Update a wallet
+        """,
+        tags=[
+            "Wallet",
+        ],
+    )
+    def partial_update(self, request: Request, *args: typing.Any, **kwargs: typing.Any):
+        return super().partial_update(request, *args, **kwargs)
+
+    @swagger_auto_schema(
+        operation_summary="List User Wallets",
+        operation_description="""
+                List User Wallets
+            """,
+        tags=[
+            "Wallet",
+        ],
+    )
+    def list(
+        self, request: Request, *args: typing.Any, **kwargs: typing.Any
+    ) -> Response:
+        return super().list(request=request, *args, **kwargs)
+
+    @swagger_auto_schema(
+        operation_summary="top up a wallet",
+        operation_description="""
+                top up a user wallet with tap payment
+            """,
+        tags=[
+            "Wallet",
+        ],
+    )
+    @action(
+        methods=["POST"],
+        detail=True,
+        url_path="top-up",
+        url_name="top-up",
+        serializer_class=WalletTopUpSerializer,
+    )
+    def top_up_wallet(
+        self, request: Request, *args: typing.Any, **kwargs: typing.Any
+    ) -> Response:
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        instance = self.get_object()
+        payment_url = serializer.top_up_wallet(instance)
+        return Response({"payment_url": payment_url}, status=status.HTTP_200_OK)

{ob-dj-store-0.0.11.8 → ob-dj-store-0.0.11.10}/ob_dj_store/core/stores/admin.py

@@ -104,12 +104,6 @@ class CategoryAdmin(admin.ModelAdmin):
         "is_active",
     ]
 
-    def save_model(self, request, obj, form, change) -> None:
-        from ob_dj_store.core.stores.receivers import create_media_thumbnails
-
-        create_media_thumbnails(None, obj, None)
-        return super().save_model(request, obj, form, change)
-
 
 class ProductVariantAdmin(admin.ModelAdmin):
     inlines = [
@@ -122,6 +116,9 @@ class ProductVariantAdmin(admin.ModelAdmin):
     ]
     search_fields = ["name", "product__name", "sku"]
 
+    def get_queryset(self, request):
+        return super().get_queryset(request).prefetch_related("inventories")
+
 
 class ProductAdmin(admin.ModelAdmin):
     list_display = ["id", "name", "category", "type", "is_active"]
@@ -249,6 +246,9 @@ class InventoryAdmin(admin.ModelAdmin):
         "is_uncountable",
     ]
 
+    def get_queryset(self, request):
+        return super().get_queryset(request).prefetch_related("store")
+
 
 class TaxAdmin(admin.ModelAdmin):
     list_display = [

{ob-dj-store-0.0.11.8 → ob-dj-store-0.0.11.10}/ob_dj_store/core/stores/admin_inlines.py

@@ -22,10 +22,10 @@ class InventoryInlineAdmin(admin.TabularInline):
     extra = 1
 
     def get_queryset(self, request):
-        qs = super().get_queryset(request)
-        return qs.select_related(
-            "store",
-            "variant",
+        return (
+            super()
+            .get_queryset(request)
+            .select_related("variant", "store", "variant__product")
         )
 
 

{ob-dj-store-0.0.11.8 → ob-dj-store-0.0.11.10}/ob_dj_store/core/stores/gateway/tap/models.py

@@ -93,7 +93,7 @@ class TapPayment(models.Model):
 
     @property
     def amount(self):
-        return self.payment.amount
+        return self.payment.total_payment
 
     def callback_update(self, tap_payload):
         if self.status == self.Status.INITIATED:

{ob-dj-store-0.0.11.8 → ob-dj-store-0.0.11.10}/ob_dj_store/core/stores/managers.py

@@ -6,7 +6,6 @@ from django.db import models
 from django.utils.translation import gettext_lazy as _
 
 from config import settings
-from ob_dj_store.core.stores.utils import get_country_by_currency
 
 
 class ActiveMixin:
@@ -77,8 +76,7 @@ class PaymentManager(models.Manager):
             return instance
         elif gateway == settings.WALLET:
             try:
-                country = get_country_by_currency(currency)
-                wallet = kwargs["user"].wallets.get(country=country)
+                wallet = kwargs["user"].wallets.get(currency=currency)
             except ObjectDoesNotExist:
                 raise ValidationError({"wallet": _("Wallet Not Found")})
             WalletTransaction.objects.create(

ob-dj-store-0.0.11.10/ob_dj_store/core/stores/migrations/0062_auto_20230226_2005.py

@@ -0,0 +1,43 @@
+# Generated by Django 3.2.8 on 2023-02-26 17:05
+
+from django.conf import settings
+from django.db import migrations, models
+
+import ob_dj_store.core.stores.utils
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("stores", "0061_auto_20230223_1435"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="store",
+            name="currency",
+            field=models.CharField(
+                default="KWD",
+                max_length=3,
+                validators=[ob_dj_store.core.stores.utils.validate_currency],
+            ),
+        ),
+        migrations.AddField(
+            model_name="wallet",
+            name="currency",
+            field=models.CharField(
+                default="KWD",
+                max_length=3,
+                validators=[ob_dj_store.core.stores.utils.validate_currency],
+            ),
+        ),
+        migrations.AlterUniqueTogether(
+            name="wallet",
+            unique_together={("user", "currency")},
+        ),
+        migrations.RemoveField(
+            model_name="wallet",
+            name="country",
+        ),
+    ]

ob-dj-store-0.0.11.10/ob_dj_store/core/stores/migrations/0063_alter_store_payment_methods.py

@@ -0,0 +1,23 @@
+# Generated by Django 3.2.8 on 2023-02-27 11:15
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("stores", "0062_auto_20230226_2005"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="store",
+            name="payment_methods",
+            field=models.ManyToManyField(
+                blank=True,
+                help_text="Payment methods within the store",
+                related_name="stores",
+                to="stores.PaymentMethod",
+            ),
+        ),
+    ]

ob-dj-store-0.0.11.10/ob_dj_store/core/stores/migrations/0064_auto_20230228_1814.py

@@ -0,0 +1,24 @@
+# Generated by Django 3.2.8 on 2023-02-28 15:14
+
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("stores", "0063_alter_store_payment_methods"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="favorite",
+            name="name",
+            field=models.CharField(blank=True, max_length=200, null=True),
+        ),
+        migrations.AlterUniqueTogether(
+            name="favorite",
+            unique_together={("name", "user")},
+        ),
+    ]

ob-dj-store-0.0.11.10/ob_dj_store/core/stores/migrations/0065_auto_20230228_1932.py

@@ -0,0 +1,34 @@
+# Generated by Django 3.2.8 on 2023-02-28 16:32
+
+from django.db import migrations, models
+
+import ob_dj_store.utils.helpers
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("stores", "0064_auto_20230228_1814"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="wallet",
+            name="image",
+            field=models.ImageField(
+                blank=True,
+                null=True,
+                upload_to=ob_dj_store.utils.helpers.wallet_media_upload_to,
+            ),
+        ),
+        migrations.AddField(
+            model_name="wallet",
+            name="image_thumbnail_medium",
+            field=models.ImageField(blank=True, null=True, upload_to="wallets/"),
+        ),
+        migrations.AddField(
+            model_name="wallet",
+            name="name",
+            field=models.CharField(blank=True, max_length=200, null=True),
+        ),
+    ]

{ob-dj-store-0.0.11.8 → ob-dj-store-0.0.11.10}/ob_dj_store/core/stores/models/_favorite.py

@@ -16,6 +16,7 @@ class Favorite(DjangoModelCleanMixin, models.Model):
     user = models.ForeignKey(
         get_user_model(), related_name="favorites", on_delete=models.CASCADE
     )
+    name = models.CharField(max_length=200, null=True, blank=True)
     content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
     content_object = GenericForeignKey("content_type", "object_id")
     object_id = models.PositiveIntegerField()
@@ -26,18 +27,20 @@ class Favorite(DjangoModelCleanMixin, models.Model):
     class Meta:
         verbose_name = _("favorite")
         verbose_name_plural = _("favorites")
+        unique_together = (("name", "user"),)
 
     def __str__(self):
         return f"{self.user} favorites {self.content_object}"
 
     @classmethod
-    def add_favorite(cls, content_object, user, extras=[]):
+    def add_favorite(cls, content_object, user, name, extras=[]):
         content_type = ContentType.objects.get_for_model(type(content_object))
         favorite = Favorite(
             user=user,
             content_type=content_type,
             object_id=content_object.pk,
             content_object=content_object,
+            name=name,
         )
         favorite.save()
         for extra in extras:

{ob-dj-store-0.0.11.8 → ob-dj-store-0.0.11.10}/ob_dj_store/core/stores/models/_order.py

@@ -119,6 +119,8 @@ class Order(DjangoModelCleanMixin, models.Model):
 
     @property
     def total_amount(self):
+        if self.type_of_order == Order.OrderType.WALLET.value:
+            return Decimal(self.extra_infos["amount"])
         amount = Decimal(
             sum(map(lambda item: Decimal(item.total_amount) or 0, self.items.all()))
         )

{ob-dj-store-0.0.11.8 → ob-dj-store-0.0.11.10}/ob_dj_store/core/stores/models/_payment.py

@@ -110,17 +110,36 @@ class Payment(models.Model):
         return f"Payment (PK={self.pk})"
 
     def mark_paid(self):
+        """
+        mark payment and orders as paid then perform post payment actions
+        if wallet fill up we add wallet transaction to the user
+        if physical order we decrease the quantity from inventory and delete items from cart
+        """
+        from ob_dj_store.core.stores.models._wallet import WalletTransaction
+
         self.status = self.PaymentStatus.SUCCESS
-        orders = list(self.orders.all())
-        cart = self.user.cart
-        for order in orders:
+        orders = self.orders.all()
+        if orders[0].type_of_order == Order.OrderType.WALLET.value:
+            order = orders[0]
+            currency = order.extra_infos["currency"]
+            wallet = self.user.wallets.get(currency=currency)
+            WalletTransaction.objects.create(
+                wallet=wallet,
+                amount=self.amount,  # TODO: cunfused about how we hundle if he want to fill up other currency
+                type=WalletTransaction.TYPE.CREDIT,
+            )
             order.status = Order.OrderStatus.PAID
-            for item in order.items.all():
-                if item.inventory:
-                    item.inventory.decrease(item.quantity)
             order.save()
-            items = order.store.store_items.filter(cart=cart)
-            items.delete()
+        else:
+            cart = self.user.cart
+            for order in orders:
+                order.status = Order.OrderStatus.PAID
+                for item in order.items.all():
+                    if item.inventory:
+                        item.inventory.decrease(item.quantity)
+                order.save()
+                items = order.store.store_items.filter(cart=cart)
+                items.delete()
         self.payment_post_at = timezone.now()
         self.save()
 
@@ -130,14 +149,15 @@ class Payment(models.Model):
 
     @property
     def total_payment(self):
+        orders = self.orders.all()
         sum_orders = Decimal(
-            sum(map(lambda order: Decimal(order.total_amount) or 0, self.orders.all()))
+            sum(map(lambda order: Decimal(order.total_amount) or 0, orders))
         )
         if self.payment_tax.rate == Tax.Rates.PERCENTAGE:
             perc = Decimal(sum_orders * self.payment_tax.value / 100)
-            return sum_orders + perc
+            return round(sum_orders + perc, 3)
 
-        return sum_orders + Decimal(self.payment_tax.value)
+        return round(sum_orders + self.payment_tax.value, 3)
 
     @property
     def type_of_order(self):