ob-dj-store 0.0.11.3__py3-none-any.whl → 0.0.11.10__py3-none-any.whl

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,
@@ -72,7 +74,6 @@ class StoreFilter(filters.FilterSet):
 class ProductFilter(filters.FilterSet):
     """Product filters"""
 
-    store = filters.CharFilter(method="by_store")
     category = filters.CharFilter(method="by_category")
 
     class Meta:
@@ -80,20 +81,9 @@ class ProductFilter(filters.FilterSet):
         fields = [
             "is_featured",
             "type",
-            "store",
             "category",
         ]
 
-    def by_store(self, queryset, name, value):
-        return queryset.prefetch_related(
-            Prefetch(
-                "products",
-                queryset=Product.objects.filter(
-                    product_variants__inventories__store=value
-                ),
-            )
-        ).filter(product_variants__inventories__store=value)
-
     def by_category(self, queryset, name, value):
         return queryset.filter(category__name__iexact=value)
 
@@ -123,22 +113,25 @@ class CategoryFilter(filters.FilterSet):
 
     def by_store(self, queryset, name, value):
         return (
-            queryset.prefetch_related(
+            queryset.filter(
+                subcategories__products__product_variants__inventories__store=value
+            )
+            .prefetch_related(
                 Prefetch(
                     "subcategories",
-                    queryset=Category.objects.exclude(
-                        products__isnull=True,
-                    ),
+                    queryset=Category.objects.filter(
+                        products__product_variants__inventories__store=value
+                    ).distinct(),
                 ),
                 Prefetch(
                     "subcategories__products",
                     queryset=Product.objects.filter(
                         product_variants__inventories__store=value,
                         is_active=True,
-                    ),
+                    ).distinct(),
                 ),
+                "subcategories__products__images",
             )
-            .filter(subcategories__products__product_variants__inventories__store=value)
             .distinct()
         )
 
@@ -184,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/apis/stores/rest/serializers/serializers.py

@@ -1,4 +1,5 @@
 import calendar
+import sys
 import typing
 from datetime import time, timedelta
 
@@ -38,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
@@ -50,6 +52,7 @@ class AttributeChoiceSerializer(serializers.ModelSerializer):
             "id",
             "name",
             "price",
+            "is_default",
         )
 
 
@@ -68,19 +71,22 @@ class AttributeSerializer(serializers.ModelSerializer):
 class InventoryValidationMixin:
     def validate(self, attrs: typing.Dict) -> typing.Dict:
         validated_data = super().validate(attrs)
-        if validated_data["product_variant"].has_inventory:
-            if validated_data["quantity"] < 1:
-                raise serializers.ValidationError(_("Quantity must be greater than 0."))
-            # validate quantity in inventory
+        inventory = None
+        try:
             inventory = validated_data["product_variant"].inventories.get(
                 store=validated_data["store"]
             )
-            if not inventory.is_uncountable:
-                stock_quantity = inventory.quantity
-                if validated_data["quantity"] > stock_quantity:
-                    raise serializers.ValidationError(
-                        _("Quantity is greater than the stock quantity.")
-                    )
+        except:
+            raise serializers.ValidationError(_("Product has no inventory"))
+        if validated_data["quantity"] < 1:
+            raise serializers.ValidationError(_("Quantity must be greater than 0."))
+        # validate quantity in inventory
+        if not inventory.is_uncountable:
+            stock_quantity = inventory.quantity
+            if validated_data["quantity"] > stock_quantity:
+                raise serializers.ValidationError(
+                    _("Quantity is greater than the stock quantity.")
+                )
         return validated_data
 
 
@@ -283,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(
                         {
@@ -397,6 +403,8 @@ class ProductAttributeSerializer(serializers.ModelSerializer):
             "is_mandatory",
             "attribute_choices",
             "type",
+            "min",
+            "max",
         )
 
 
@@ -427,6 +435,8 @@ class ProductVariantSerializer(serializers.ModelSerializer):
 
 class CartItemSerializer(InventoryValidationMixin, serializers.ModelSerializer):
     image = serializers.SerializerMethodField()
+    inventory_quantity = serializers.SerializerMethodField()
+    is_uncountable = serializers.SerializerMethodField()
 
     class Meta:
         model = CartItem
@@ -442,6 +452,8 @@ class CartItemSerializer(InventoryValidationMixin, serializers.ModelSerializer):
             "extra_infos",
             "attribute_choices_total_price",
             "image",
+            "inventory_quantity",
+            "is_uncountable",
         )
         extra_kwargs = {
             "store": {
@@ -449,6 +461,16 @@ class CartItemSerializer(InventoryValidationMixin, serializers.ModelSerializer):
             },
         }
 
+    def get_inventory_quantity(self, obj):
+        if obj.inventory:
+            return obj.inventory.quantity
+        return None
+
+    def get_is_uncountable(self, obj):
+        if obj.inventory:
+            return obj.inventory.is_uncountable
+        return None
+
     def validate(self, attrs: typing.Dict) -> typing.Dict:
         return super(CartItemSerializer, self).validate(attrs)
 
@@ -515,9 +537,16 @@ class CartSerializer(serializers.ModelSerializer):
             cart_item.save()
         return instance
 
+    def to_representation(self, instance):
+        data = super().to_representation(instance)
+        stores = Store.objects.filter(store_items__cart=instance)
+        data["store"] = StoreSerializer(stores, many=True, context=self.context).data
+        return data
+
 
 class ProductMediaSerializer(serializers.ModelSerializer):
-    image_thumbnail = serializers.ImageField(read_only=True)
+    image_thumbnail_medium = serializers.ImageField(read_only=True)
+    image_thumbnail_small = serializers.ImageField(read_only=True)
 
     class Meta:
         model = ProductMedia
@@ -525,7 +554,8 @@ class ProductMediaSerializer(serializers.ModelSerializer):
             "id",
             "is_primary",
             "image",
-            "image_thumbnail",
+            "image_thumbnail_small",
+            "image_thumbnail_medium",
             "order_value",
         )
 
@@ -574,8 +604,8 @@ class ProductSerializer(FavoriteMixin, serializers.ModelSerializer):
         return data
 
 
-class ProductListSerializer(ProductSerializer):
-    product_variants = ProductVariantSerializer(many=True)
+class ProductListSerializer(serializers.ModelSerializer):
+    product_images = ProductMediaSerializer(many=True, source="images")
 
     class Meta:
         model = Product
@@ -585,15 +615,14 @@ class ProductListSerializer(ProductSerializer):
             "slug",
             "description",
             "product_images",
-            "product_variants",
             "type",
-            "default_variant",
         )
 
 
 class SubCategorySerializer(serializers.ModelSerializer):
     products = ProductListSerializer(many=True)
-    image_thumbnail = serializers.ImageField(read_only=True)
+    image_thumbnail_medium = serializers.ImageField(read_only=True)
+    image_thumbnail_small = serializers.ImageField(read_only=True)
 
     class Meta:
         model = Category
@@ -604,12 +633,13 @@ class SubCategorySerializer(serializers.ModelSerializer):
             "is_active",
             "products",
             "image",
-            "image_thumbnail",
+            "image_thumbnail_medium",
+            "image_thumbnail_small",
+            "parent",
         )
 
     def to_representation(self, instance):
         data = super().to_representation(instance)
-        data["parent_id"] = instance.parent.id if instance.parent else None
         return data
 
 
@@ -627,6 +657,9 @@ class CategorySerializer(serializers.ModelSerializer):
             "is_active",
             "subcategories",
             "parent",
+            "image",
+            "image_thumbnail_medium",
+            "image_thumbnail_small",
         )
 
 
@@ -765,9 +798,7 @@ class StoreSerializer(FavoriteMixin, serializers.ModelSerializer):
 
     def get_is_closed(self, obj):
         current_time = now()
-        current_op_hour = obj.opening_hours.filter(
-            weekday=current_time.weekday() + 1
-        ).first()
+        current_op_hour = obj.current_opening_hours
         if current_op_hour:
             return (
                 not current_op_hour.from_hour
@@ -781,10 +812,11 @@ class StoreSerializer(FavoriteMixin, serializers.ModelSerializer):
         in_range_method = obj.shipping_methods.filter(
             type=ShippingMethod.ShippingType.DELIVERY
         ).exists()
-        if user_location and obj.poly and in_range_method:
+        if not in_range_method:
+            return True
+        if user_location and obj.poly:
             long, lat = user_location.split(",")
             return obj.poly.contains(Point(float(long), float(lat)))
-        return False
 
     def get_opening_hours(self, obj):
         opening_hours = sorted(
@@ -838,9 +870,7 @@ class StoreSerializer(FavoriteMixin, serializers.ModelSerializer):
         return PhoneContactSerializer(phone_contacts, many=True).data
 
     def get_current_day_opening_hours(self, obj):
-        current_opening_hours = obj.opening_hours.filter(
-            weekday=now().weekday() + 1
-        ).first()
+        current_opening_hours = obj.current_opening_hours
         op_hour = {}
         if current_opening_hours:
             op_hour["from_hour"] = current_opening_hours.from_hour.strftime("%I:%M%p")
@@ -851,15 +881,7 @@ class StoreSerializer(FavoriteMixin, serializers.ModelSerializer):
         return op_hour
 
     def to_representation(self, instance):
-        data = super().to_representation(instance)
-        view = self.context.get("view")
-        if view:
-            if view.action != "retrieve":
-                return data
-        data["inventories"] = InventorySerializer(
-            instance.inventories.all(), many=True
-        ).data
-        return data
+        return super().to_representation(instance)
 
 
 class PaymentMethodSerializer(serializers.ModelSerializer):
@@ -899,17 +921,27 @@ class StoreListSerializer(serializers.ModelSerializer):
 
 
 class GenericSerializer(serializers.Serializer):
+    """
+    A generic serializer that automatically selects the appropriate serializer
+    for a given instance.
+
+    The `to_representation` method uses the `get_serializer_for_instance` method
+    to determine which serializer to use for a given instance. If the serializer
+    class is found, it returns the representation of the instance using that
+    serializer. Otherwise, it raises a `NameError`.
+    """
+
     def to_representation(self, value):
         context = self.context
         serializer_class = self.get_serializer_for_instance(value)
         return serializer_class(context=context).to_representation(value)
 
     def get_serializer_for_instance(self, instance):
-        serializer_name = type(instance).__name__ + "Serializer"
-        try:
-            return eval(serializer_name)
-        except NameError:
-            raise NameError(_(f"name '{serializer_name}' is not defined"))
+        serializer_class = instance.__class__.__name__ + "Serializer"
+        if hasattr(sys.modules[__name__], serializer_class):
+            return getattr(sys.modules[__name__], serializer_class)
+        else:
+            raise NameError(_(f"name '{serializer_class}' is not defined"))
 
 
 class FavoriteExtraSerializer(serializers.ModelSerializer):
@@ -945,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"]))
@@ -956,6 +992,7 @@ class FavoriteSerializer(serializers.ModelSerializer):
         queryset = Favorite.objects.filter(
             content_type=content_type,
             object_id=data["content_object"].id,
+            user=self.context["request"].user,
         )
         for key in extras_lookup_content_type.keys():
             queryset = queryset.filter(
@@ -971,13 +1008,17 @@ 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:
+        if object_type not in store_settings.FAVORITE_TYPES and hasattr(
+            sys.modules[__name__], object_type
+        ):
             raise serializers.ValidationError(
                 _(f"Cannot resolve keyword '{object_type}' into an object type")
             )
+        object_type_model = getattr(sys.modules[__name__], object_type)
         object_instance = get_object_or_404(
-            eval(object_type), pk=validated_data["object_id"]
+            object_type_model, pk=validated_data["object_id"]
         )
         extras_data = {}
         extras = []
@@ -993,24 +1034,59 @@ class FavoriteSerializer(serializers.ModelSerializer):
             extras_data[extra_object_type].append(extra["object_id"])
         try:
             for key in extras_data.keys():
-                model_class = eval(key)
-                extras.append(model_class.objects.filter(id__in=extras_data[key]))
+                model_class = getattr(sys.modules[__name__], key, None)
+                if model_class:
+                    extras.append(model_class.objects.filter(id__in=extras_data[key]))
         except ObjectDoesNotExist:
             raise serializers.ValidationError(_("No matches the given query."))
-        except NameError as e:
-            raise NameError(e)
 
         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/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)),