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

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

@@ -1,7 +1,8 @@
 import calendar
 import logging
 import typing
-from datetime import timedelta
+from collections import OrderedDict
+from datetime import datetime, timedelta
 from decimal import Decimal
 
 import pycountry
@@ -51,12 +52,14 @@ from ob_dj_store.core.stores.models import (
     ShippingMethod,
     Store,
     Tax,
+    Tip,
+    TipAmount,
     Wallet,
     WalletMedia,
     WalletTransaction,
 )
 from ob_dj_store.core.stores.models._inventory import Inventory
-from ob_dj_store.core.stores.utils import PartnerAuth, distance
+from ob_dj_store.core.stores.utils import PartnerAuth, distance, get_currency_by_country
 
 logger = logging.getLogger(__name__)
 
@@ -283,6 +286,8 @@ class OrderSerializer(serializers.ModelSerializer):
             "created_at",
             "updated_at",
             "store_name",
+            "tip_percentage",
+            "tip_value",
         )
         extra_kwargs = {
             "customer": {"read_only": True},
@@ -329,8 +334,7 @@ class OrderSerializer(serializers.ModelSerializer):
         return store
 
     def _validate_user_address(
-        self,
-        attrs,
+        self, attrs,
     ):
         if "shipping_address" not in attrs:
             raise ValidationError(
@@ -362,7 +366,7 @@ class OrderSerializer(serializers.ModelSerializer):
             raise serializers.ValidationError(errors)
         email = gift_details.get("email")
         phone_number = gift_details.get("phone_number")
-
+        user = self.context["request"].user
         if email and phone_number:
             raise serializers.ValidationError(
                 _("Both Email and Phone number cannot be provided.")
@@ -376,7 +380,12 @@ class OrderSerializer(serializers.ModelSerializer):
                 validate_email(email)
             except ValidationError:
                 raise serializers.ValidationError(_("Invalid Email format."))
+        try:
+            if not gift_details["currency"]:
+                gift_details["currency"] = get_currency_by_country(user.country.code)
 
+        except Exception:
+            raise serializers.ValidationError("Currency is required")
         if not pycountry.currencies.get(alpha_3=gift_details["currency"]):
             raise serializers.ValidationError("Gift currency is not valid")
         try:
@@ -396,29 +405,39 @@ class OrderSerializer(serializers.ModelSerializer):
 
     def _validate_pickup_time(self, store, pickup_time):
         # validate that the pickup_time is always in the future
-        if pickup_time < localtime(now()):
+        if pickup_time < localtime(now(), self._get_store().timezone):
             raise serializers.ValidationError(_("Pickup time must be in the future"))
         pickup_time_time = pickup_time.time()
         # validate that the pickup_time is between store's opening hours and closing hours
         try:
             op_hour = store.opening_hours.get(weekday=pickup_time.weekday() + 1)
+            from_hour = op_hour.from_hour
+            to_hour = op_hour.to_hour
             if store.currency == "AED":
-                op_hour.to_hour = op_hour.to_hour + timedelta(hours=1)
-                op_hour.from_hour = op_hour.to_hour + timedelta(hours=1)
-                op_hour.save()
-            if store.is_open_after_midnight:
-                if op_hour.to_hour < pickup_time_time < op_hour.from_hour:
-                    raise serializers.ValidationError(
-                        _("Pickup time must be between store's opening hours")
+                try:
+                    pickup_time_time += timedelta(hours=1)
+                except Exception as e:
+                    logger.info(
+                        f"The fix for UAE stores timezone failed due to this error {e}"
                     )
-            elif (
-                not op_hour.always_open
-                and pickup_time_time > op_hour.to_hour
-                or pickup_time_time < op_hour.from_hour
+
+            if (
+                op_hour.is_open_after_midnight
+                and not op_hour.always_open
+                and (pickup_time_time > to_hour and pickup_time_time < from_hour)
             ):
                 raise serializers.ValidationError(
                     _("Pickup time must be between store's opening hours")
                 )
+            if (
+                not op_hour.is_open_after_midnight
+                and not op_hour.always_open
+                and not from_hour <= pickup_time_time <= to_hour
+            ):
+                raise serializers.ValidationError(
+                    _("Pickup time must be between store's opening hours")
+                )
+
         except ObjectDoesNotExist:
             logger.error(f"{store.name} Store doesn't have opening hours for ")
 
@@ -434,6 +453,7 @@ class OrderSerializer(serializers.ModelSerializer):
             attrs["extra_infos"] = {}
         stores = Store.objects.filter(store_items__cart=user.cart).distinct()
         gift_details = attrs["extra_infos"].get("gift_details", None)
+        unavailable_items = []
         if gift_details:
             self._validate_digital_product(gift_details, attrs)
             currency = gift_details["currency"]
@@ -445,7 +465,17 @@ class OrderSerializer(serializers.ModelSerializer):
                 if len(stores) > 1:
                     raise ValidationError(_("You cannot order from different stores"))
                 for item in user.cart.items.all():
-                    if not item.inventory:
+                    if item.inventory:
+                        if item.inventory.is_snoozed:
+                            unavailable_items.append(item)
+                        elif not item.inventory.is_uncountable:
+                            if (
+                                not item.inventory.quantity
+                                or item.inventory.quantity == 0
+                            ):
+                                unavailable_items.append(item)
+
+                    elif not item.inventory:
                         if language and item.product_variant.product.name_arabic:
                             product_name = item.product_variant.product.name_arabic
                         else:
@@ -455,8 +485,14 @@ class OrderSerializer(serializers.ModelSerializer):
                         message = (
                             f"{product_name} {variant_name} doesn't exist on this store"
                         )
+                        unavailable_items.append(item)
                         raise ValidationError(_(message))
-
+                if unavailable_items:
+                    raise ValidationError(
+                        _(
+                            "The cart has items that are not available in the selected store"
+                        )
+                    )
             if "shipping_method" in attrs:
                 if (
                     attrs["shipping_method"].type
@@ -496,9 +532,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,
@@ -507,21 +549,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):
@@ -533,7 +594,12 @@ class OrderSerializer(serializers.ModelSerializer):
             amount = gift_details["price"]
             order = Order.objects.create(customer=user, **validated_data)
             orders.append(order)
-            currency = gift_details["currency"]
+            try:
+                default_currency = get_currency_by_country(user.country.code)
+            except Exception as e:
+                default_currency = "KWD"
+                logger.info(f"Couldn't fetch currency due to this error {e}")
+            currency = gift_details.get("currency", default_currency)
         else:
             cart = user.cart
             stores = Store.objects.filter(store_items__cart=cart).distinct()
@@ -552,7 +618,11 @@ class OrderSerializer(serializers.ModelSerializer):
                         attributes=list(item.attribute_choices.all()),
                         notes=item.notes,
                     )
+                if order.tip_percentage:
+                    order.tip_value = order.calculate_tip()
+                    order.save()
                 orders.append(order)
+
             amount = Decimal(
                 sum(map(lambda order: Decimal(order.total_amount) or 0, orders))
             )
@@ -703,9 +773,7 @@ class CartItemSerializer(
             "is_multi_variant",
         )
         extra_kwargs = {
-            "store": {
-                "required": True,
-            },
+            "store": {"required": True,},
         }
 
     def get_is_multi_variant(self, obj):
@@ -713,7 +781,10 @@ class CartItemSerializer(
         return product.product_variants.all().count() > 1
 
     def get_is_available_in_store(self, obj):
-        return True if obj.inventory else False
+        if obj.inventory:
+            if obj.inventory.quantity:
+                return True
+        return False
 
     def get_product_id(self, obj):
         return obj.product_variant.product.id
@@ -743,9 +814,9 @@ class CartItemSerializer(
         favorites = Favorite.objects.favorites_for_object(
             obj.product_variant.product, user
         )
-        customization = [
-            obj.product_variant,
-        ] + [attribute_choice for attribute_choice in obj.attribute_choices.all()]
+        customization = [obj.product_variant,] + [
+            attribute_choice for attribute_choice in obj.attribute_choices.all()
+        ]
         for favorite in favorites:
             content_objects = [
                 instance.content_object for instance in favorite.extras.all()
@@ -820,10 +891,19 @@ class CartSerializer(ArabicFieldsMixin, serializers.ModelSerializer):
         # update or create instance items
         for item in validated_data["items"]:
             attribute_choices = item.pop("attribute_choices", None)
-            cart_item = CartItem.objects.create(
+            logger.info("cart item :", item)
+            cart_item, created = CartItem.objects.get_or_create(
                 cart=instance,
-                **item,
+                pk=item.pop("id", None),
+                defaults={
+                    "cart": instance,
+                    "product_variant": item.pop("product_variant", None),
+                    "store": item.pop("store", None),
+                    "notes": item.pop("notes", None),
+                    "quantity": item.pop("quantity", None),
+                },
             )
+
             if attribute_choices:
                 cart_item.attribute_choices.set(attribute_choices)
             cart_item.save()
@@ -899,6 +979,44 @@ class ProductSerializer(ArabicFieldsMixin, FavoriteMixin, serializers.ModelSeria
         return data
 
 
+class ProductSearchSerializer(
+    ArabicFieldsMixin, FavoriteMixin, serializers.ModelSerializer
+):
+    is_snoozed = serializers.SerializerMethodField()
+    is_available = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Product
+        fields = (
+            "id",
+            "name",
+            "name_arabic",
+            "slug",
+            "description",
+            "description_arabic",
+            "is_snoozed",
+            "is_available",
+        )
+
+    def get_store_id(self):
+        return self.context["view"].kwargs["store_pk"]
+
+    def get_inventory_for_store(self, product, store_id):
+        if store_id:
+            return product.get_inventory(store_id)
+        return None
+
+    def get_is_snoozed(self, obj):
+        store_id = self.get_store_id()
+        inventory = self.get_inventory_for_store(obj, store_id)
+        return obj.is_snoozed(store_id=store_id) if inventory else False
+
+    def get_is_available(self, obj):
+        store_id = self.get_store_id()
+        inventory = self.get_inventory_for_store(obj, store_id)
+        return bool(inventory and (inventory.quantity or inventory.is_uncountable))
+
+
 class ProductListSerializer(ArabicFieldsMixin, serializers.ModelSerializer):
     product_images = ProductMediaSerializer(many=True, source="images")
 
@@ -948,11 +1066,13 @@ class SubCategorySerializer(ArabicFieldsMixin, serializers.ModelSerializer):
     def get_is_available(self, obj) -> bool:
         store_id = self.context["request"].query_params.get("store", None)
         if store_id:
+            local_tz = Store.objects.get(id=store_id).timezone
+            current_time = localtime(now(), local_tz) if local_tz else localtime(now())
             for availability_hours in obj.parent.availability_hours.all():
                 if availability_hours.category == obj.parent:
                     return (
                         availability_hours.from_hour
-                        <= localtime(now()).time()
+                        <= current_time.time()
                         <= availability_hours.to_hour
                     )
         return False
@@ -984,11 +1104,13 @@ class CategorySerializer(ArabicFieldsMixin, serializers.ModelSerializer):
     def get_is_available(self, obj) -> bool:
         store_id = self.context["request"].query_params.get("store", None)
         if store_id:
+            local_tz = Store.objects.get(id=store_id).timezone
+            current_time = localtime(now(), local_tz) if local_tz else localtime(now())
             for availability_hours in obj.availability_hours.all():
                 if availability_hours.category == obj:
                     return (
                         availability_hours.from_hour
-                        <= localtime(now()).time()
+                        <= current_time.time()
                         <= availability_hours.to_hour
                     )
         return False
@@ -1099,6 +1221,7 @@ class StoreSerializer(ArabicFieldsMixin, FavoriteMixin, serializers.ModelSeriali
     shipping_methods = ShippingMethodSerializer(many=True, read_only=True)
     distance = serializers.SerializerMethodField()
     current_day_opening_hours = serializers.SerializerMethodField()
+    timezone = serializers.SerializerMethodField()
 
     class Meta:
         model = Store
@@ -1127,7 +1250,7 @@ class StoreSerializer(ArabicFieldsMixin, FavoriteMixin, serializers.ModelSeriali
             "image",
             "busy_mode",
             "name_arabic",
-            "is_open_after_midnight",
+            "timezone",
         )
         extra_kwargs = {
             "image": {"read_only": True, "required": False},
@@ -1136,26 +1259,26 @@ class StoreSerializer(ArabicFieldsMixin, FavoriteMixin, serializers.ModelSeriali
     def get_is_closed(self, obj):
         if obj.busy_mode:
             return True
-
-        current_time = localtime(now())
+        current_time = localtime(now(), obj.timezone)
         current_op_hour = obj.current_opening_hours
         if current_op_hour:
-            if obj.is_open_after_midnight:
-                return (
-                    True
-                    if current_op_hour.to_hour
-                    < current_time.time()
-                    < current_op_hour.from_hour
-                    else False
-                )
+            from_hour = current_op_hour.from_hour
+            to_hour = current_op_hour.to_hour
+            if current_time.tzinfo != "Asia/Dubai":
+                if obj.currency == "AED":
+                    try:
+                        current_time += timedelta(hours=1)
+                    except Exception as e:
+                        logger.info(
+                            f"The fix for UAE stores timezone failed due to this error {e}"
+                        )
+
+            if current_op_hour.is_open_after_midnight:
+                return True if to_hour < current_time.time() < from_hour else False
 
             if current_op_hour.always_open:
                 return False
-            return (
-                not current_op_hour.from_hour
-                <= current_time.time()
-                <= current_op_hour.to_hour
-            )
+            return not from_hour <= current_time.time() <= to_hour
         return True
 
     def get_in_range_delivery(self, obj):
@@ -1255,6 +1378,9 @@ class StoreSerializer(ArabicFieldsMixin, FavoriteMixin, serializers.ModelSeriali
             op_hour = f"{settings.DEFAULT_OPENING_HOURS[0]['from_hour']} - {settings.DEFAULT_OPENING_HOURS[0]['to_hour']}"
         return op_hour
 
+    def get_timezone(self, obj):
+        return str(obj.timezone)
+
     def to_representation(self, instance):
         return super().to_representation(instance)
 
@@ -1293,10 +1419,15 @@ class TaxSerializer(serializers.ModelSerializer):
 
 
 class StoreListSerializer(ArabicFieldsMixin, serializers.ModelSerializer):
+    timezone = serializers.SerializerMethodField()
+
     class Meta:
         model = Store
         fields = "__all__"
 
+    def get_timezone(self, obj):
+        return str(obj.timezone)
+
 
 class GenericSerializer(serializers.Serializer):
     """
@@ -1392,9 +1523,12 @@ class FavoriteSerializer(ArabicFieldsMixin, serializers.ModelSerializer):
             try:
                 extra = obj.extras.get(content_type=content_type)
                 inventory = extra.content_object.inventories.get(store=store_id)
-                if inventory.is_uncountable:
-                    return True
-                return inventory.quantity > 0
+                if inventory.is_snoozed:
+                    return False
+                else:
+                    if inventory.is_uncountable:
+                        return True
+                    return False
             except ObjectDoesNotExist:
                 return False
         return None
@@ -1566,6 +1700,7 @@ class WalletTopUpSerializer(serializers.Serializer):
                 store_settings.GOOGLE_PAY,
                 store_settings.MADA,
                 store_settings.BENEFIT,
+                store_settings.STRIPE,
             ]
         ),
         required=True,
@@ -1597,6 +1732,39 @@ class WalletTransactionSerializer(serializers.ModelSerializer):
         ]
 
 
+class GroupedWalletTransactionListSerializer(serializers.ListSerializer):
+    def to_representation(self, data):
+        result_dict = OrderedDict()
+        for wallettransaction in data:
+            year = wallettransaction.created_at.year
+            month = wallettransaction.created_at.month
+            title = f"{datetime(year, month, 1).strftime('%b')}, {year}"
+
+            if title not in result_dict:
+                result_dict[title] = {"title": title, "data": []}
+
+            result_dict[title]["data"].append(
+                self.child.to_representation(wallettransaction)
+            )
+
+        return list(result_dict.values())
+
+
+class WalletTransactionListSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = WalletTransaction
+        fields = [
+            "id",
+            "type",
+            "amount",
+            "created_at",
+            "wallet",
+            "is_cashback",
+            "is_refund",
+        ]
+        list_serializer_class = GroupedWalletTransactionListSerializer
+
+
 class ReorderSerializer(serializers.Serializer):
     force_cart = serializers.BooleanField(default=False)
 
@@ -1769,9 +1937,7 @@ class PartnerAuthInfoSerializer(ArabicFieldsMixin, serializers.ModelSerializer):
                     status=OneTruePairing.Statuses.init,
                     created_at__gte=timeout,
                 ).get(
-                    email=attrs["email"],
-                    partner_otp_auth__partner=partner,
-                    user=user,
+                    email=attrs["email"], partner_otp_auth__partner=partner, user=user,
                 )
                 self.context["otp"] = otp
             except ObjectDoesNotExist as e:
@@ -1808,11 +1974,7 @@ class PartnerAuthInfoSerializer(ArabicFieldsMixin, serializers.ModelSerializer):
             otp.status = OneTruePairing.Statuses.used
             otp.save()
         partner_auth_info = PartnerAuthInfo.objects.update_or_create(
-            user=user,
-            defaults={
-                "partner": partner,
-                "email": validated_data["email"],
-            },
+            user=user, defaults={"partner": partner, "email": validated_data["email"],},
         )
         return partner_auth_info
 
@@ -1836,3 +1998,34 @@ class CountryPaymentMethodSerialzier(serializers.ModelSerializer):
             instance=qs, context=self.context, many=True
         ).data
         return data
+
+
+class TipSerializer(serializers.ModelSerializer):
+    tip_amounts = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Tip
+        fields = (
+            "id",
+            "name",
+            "description",
+            "is_applied",
+            "country",
+            "is_active",
+            "tip_amounts",
+        )
+
+    def get_tip_amounts(self, obj):
+        from .serializers import TipAmountSerializer  # avoid circular import
+
+        tip_amounts = obj.tip_amounts.all()
+        return TipAmountSerializer(tip_amounts, many=True).data
+
+
+class TipAmountSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = TipAmount
+        fields = (
+            "id",
+            "percentage",
+        )

ob_dj_store/apis/stores/urls.py

@@ -18,8 +18,10 @@ from ob_dj_store.apis.stores.views import (
     ShippingMethodViewSet,
     StoreView,
     TaxViewSet,
+    TipsViewSet,
     TransactionsViewSet,
     VariantView,
+    WalletV2ViewSet,
     WalletViewSet,
 )
 
@@ -43,6 +45,7 @@ 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"wallet_v2", WalletV2ViewSet, basename="wallet_v2")
 router.register(r"payment-method", PaymentMethodViewSet, basename="payment-method")
 router.register(r"order", ReorderViewSet, basename="re-order")
 router.register(r"partner/auth", PartnerAuthInfoViewSet, basename="auth")
@@ -52,6 +55,9 @@ router.register(
     CountryPaymentMethodsViewSet,
     basename="country-payment-methods",
 )
+router.register(
+    r"tip", TipsViewSet, basename="tip",
+)
 
 urlpatterns = [
     path(r"", include(router.urls)),