ob-dj-store 0.0.15.18__py3-none-any.whl → 0.0.16.1__py3-none-any.whl

ob_dj_store/apis/stores/filters.py

@@ -17,7 +17,7 @@ from ob_dj_store.core.stores.models import (
 )
 from ob_dj_store.core.stores.models._inventory import Inventory
 from ob_dj_store.core.stores.models._wallet import Wallet
-from ob_dj_store.core.stores.utils import validate_currency
+from ob_dj_store.core.stores.utils import get_currency_by_country, validate_currency
 
 
 class StoreFilter(filters.FilterSet):
@@ -268,9 +268,15 @@ class WalletFilter(filters.FilterSet):
             validate_currency,
         ],
     )
+    country = filters.CharFilter(method="by_country")
 
     class Meta:
         models = Wallet
 
     def by_currency(self, queryset, name, value):
         return queryset.filter(currency=value)
+
+    def by_country(self, queryset, name, value):
+        if value:
+            currency = get_currency_by_country(value)
+            return queryset.filter(currency=currency)

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

@@ -16,6 +16,7 @@ from django.shortcuts import get_object_or_404
 from django.utils.module_loading import import_string
 from django.utils.timezone import localtime, now
 from django.utils.translation import gettext_lazy as _
+from ob_dj_otp.core.otp.models import OneTruePairing
 from phonenumber_field.phonenumber import to_python
 from rest_framework import serializers
 
@@ -35,6 +36,9 @@ from ob_dj_store.core.stores.models import (
     Order,
     OrderHistory,
     OrderItem,
+    Partner,
+    PartnerAuthInfo,
+    PartnerOTPAuth,
     Payment,
     PaymentMethod,
     PhoneContact,
@@ -51,7 +55,7 @@ from ob_dj_store.core.stores.models import (
     WalletTransaction,
 )
 from ob_dj_store.core.stores.models._inventory import Inventory
-from ob_dj_store.core.stores.utils import distance
+from ob_dj_store.core.stores.utils import PartnerAuth, distance
 
 logger = logging.getLogger(__name__)
 
@@ -176,6 +180,7 @@ class OrderSerializer(serializers.ModelSerializer):
             "total_amount",
             "preparation_time",
             "estimated_timeline",
+            "get_discount_amount",
             "history",
             "car_id",
             "pickup_time",
@@ -653,6 +658,8 @@ class CartSerializer(serializers.ModelSerializer):
             "total_price",
             "tax_amount",
             "total_price_with_tax",
+            "discount_offer_amount",
+            "total_price_with_discount",
         )
         read_only_fields = (
             "id",
@@ -1193,6 +1200,7 @@ class FavoriteSerializer(serializers.ModelSerializer):
             "content_object",
             "extras",
             "object_id",
+            "extra_info",
             "object_type",
             "name",
             "is_available_in_store",
@@ -1309,6 +1317,7 @@ class FavoriteSerializer(serializers.ModelSerializer):
             "content_object": object_instance,
             "extras": extras,
             "name": validated_data["name"],
+            "extra_info": validated_data.get("extra_info", None),
         }
         self._lookup_validation(validated_data)
         return validated_data
@@ -1319,6 +1328,7 @@ class FavoriteSerializer(serializers.ModelSerializer):
                 content_object=validated_data["content_object"],
                 user=self.context["request"].user,
                 name=validated_data["name"],
+                extra_info=validated_data["extra_info"],
                 extras=validated_data["extras"],
             )
         except ValidationError as e:
@@ -1329,6 +1339,7 @@ class FavoriteSerializer(serializers.ModelSerializer):
         try:
             favorite = instance.update_favorite(
                 validated_data["name"],
+                validated_data["extra_info"],
                 validated_data["extras"],
             )
         except ValidationError as e:
@@ -1456,3 +1467,149 @@ class OrderDataSerializer(serializers.ModelSerializer):
 
     def get_shipping_method_name(self, obj):
         return obj.shipping_method.name if obj.shipping_method else None
+
+
+class PartnerOTPRequestSerializer(serializers.ModelSerializer):
+    email = serializers.EmailField(required=True)
+
+    class Meta:
+        model = PartnerOTPAuth
+        exclude = ("user", "otp", "partner")
+
+    def _validate_old_valid_verification_code(self, attrs):
+        # Validate there is unused OTP code
+        timeout = now() - timedelta(seconds=getattr(settings, "OTP_TIMEOUT", 3 * 60))
+        qs = PartnerOTPAuth.objects.filter(
+            created_at__gte=timeout, email=attrs["email"]
+        )
+        if qs.exists():
+            # TODO: Add a mechanism to force a new code request
+            # with a field called "force" with checking that he didn't call this api to many times
+            seconds_left = (
+                timedelta(seconds=getattr(settings, "OTP_TIMEOUT", 3 * 60))
+                - (now() - qs.last().created_at)
+            ).total_seconds()
+            minutes_left = int(seconds_left) // 60 or 1
+            raise serializers.ValidationError(
+                _(
+                    "We sent a verification code please wait for "
+                    "{minutes} minutes; before requesting a new code."
+                ).format(minutes=minutes_left)
+            )
+
+    def validate(self, attrs):
+        attrs = super().validate(attrs)
+        try:
+            partner_auth = PartnerAuth(attrs["email"])
+        except ValidationError as e:
+            raise serializers.ValidationError(detail=e.messages)
+        partner = partner_auth.partner
+        if partner.auth_method != Partner.AuthMethods.OTP:
+            raise serializers.ValidationError(
+                _(f"{partner.name} does not support OTP as Auth Method")
+            )
+        self._validate_old_valid_verification_code(attrs)
+        attrs["partner"] = partner
+        return attrs
+
+    def create(self, validated_data):
+        user = self.context["view"].request.user
+        otp = OneTruePairing.objects.create(
+            user=user, usage=OneTruePairing.Usages.auth, email=validated_data["email"]
+        )
+        partner_otp_auth = PartnerOTPAuth.objects.create(
+            user=self.context["view"].request.user,
+            partner=validated_data["partner"],
+            otp=otp,
+            email=validated_data["email"],
+        )
+        return partner_otp_auth
+
+
+class PartnerAuthInfoSerializer(serializers.ModelSerializer):
+    promotion_code = serializers.IntegerField(write_only=True, required=False)
+    otp_code = serializers.IntegerField(write_only=True, required=False)
+    email = serializers.EmailField(write_only=True, required=True)
+
+    class Meta:
+        model = PartnerAuthInfo
+        fields = (
+            "id",
+            "user",
+            "email",
+            "otp_code",
+            "promotion_code",
+            "partner",
+            "authentication_expires",
+            "created_at",
+            "updated_at",
+        )
+        extra_kwargs = {
+            "user": {"read_only": True},
+            "email": {"read_only": True},
+            "partner": {"read_only": True},
+            "authentication_expires": {"read_only": True},
+        }
+
+    def _validate_partner_auth_method(self, attrs):
+        partner = attrs["partner"]
+        user = self.context["view"].request.user
+        if partner.auth_method == Partner.AuthMethods.OTP:
+            otp_code = attrs.get("otp_code", None)
+            if otp_code == None:
+                raise serializers.ValidationError(_("OTP code is required"))
+            timeout = now() - timedelta(
+                seconds=getattr(settings, "OTP_TIMEOUT", 3 * 60)
+            )
+            try:
+                otp = OneTruePairing.objects.filter(
+                    verification_code=otp_code,
+                    status=OneTruePairing.Statuses.init,
+                    created_at__gte=timeout,
+                ).get(
+                    email=attrs["email"],
+                    partner_otp_auth__partner=partner,
+                    user=user,
+                )
+                self.context["otp"] = otp
+            except ObjectDoesNotExist as e:
+                raise serializers.ValidationError(
+                    _(f"Invalid verification code.")
+                ) from e
+
+        elif partner.auth_method == Partner.AuthMethods.CODE:
+            promotion_code = attrs.get("promotion_code", None)
+            if promotion_code == None:
+                raise serializers.ValidationError(_("Promotion code is required"))
+            elif not partner.promotion_code:
+                logger.error(f"{partner.name} does not have promotion code")
+                raise serializers.ValidationError(_("Promotion code is not working"))
+            elif partner.promotion_code != promotion_code:
+                raise serializers.ValidationError(_("Promotion code is invalid"))
+        return attrs
+
+    def validate(self, attrs):
+        attrs = super().validate(attrs)
+        try:
+            partner_auth = PartnerAuth(attrs["email"])
+        except ValidationError as e:
+            raise serializers.ValidationError(detail=e.messages)
+        attrs["partner"] = partner_auth.partner
+        self._validate_partner_auth_method(attrs)
+        return attrs
+
+    def create(self, validated_data):
+        user = self.context["view"].request.user
+        partner = validated_data["partner"]
+        if partner.auth_method == Partner.AuthMethods.OTP:
+            otp = self.context["otp"]
+            otp.status = OneTruePairing.Statuses.used
+            otp.save()
+        partner_auth_info = PartnerAuthInfo.objects.update_or_create(
+            user=user,
+            defaults={
+                "partner": partner,
+                "email": validated_data["email"],
+            },
+        )
+        return partner_auth_info

ob_dj_store/apis/stores/urls.py

@@ -9,6 +9,7 @@ from ob_dj_store.apis.stores.views import (
     FavoriteViewSet,
     InventoryView,
     OrderView,
+    PartnerAuthInfoViewSet,
     PaymentMethodViewSet,
     ProductView,
     ReorderViewSet,
@@ -42,6 +43,7 @@ router.register(r"favorite", FavoriteViewSet, basename="favorite")
 router.register(r"wallet", WalletViewSet, basename="wallet")
 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")
 urlpatterns = [
     path(r"", include(router.urls)),
     path(r"", include(stores_router.urls)),

ob_dj_store/apis/stores/views.py

@@ -41,6 +41,8 @@ from ob_dj_store.apis.stores.rest.serializers.serializers import (
     FeedbackSerializer,
     InventorySerializer,
     OrderSerializer,
+    PartnerAuthInfoSerializer,
+    PartnerOTPRequestSerializer,
     PaymentMethodSerializer,
     PaymentSerializer,
     ProductListSerializer,
@@ -65,6 +67,7 @@ from ob_dj_store.core.stores.models import (
     Favorite,
     FeedbackConfig,
     Order,
+    PartnerAuthInfo,
     Payment,
     PaymentMethod,
     PhoneContact,
@@ -1259,3 +1262,69 @@ class WalletViewSet(
 
         serializer = self.get_serializer(queryset, many=True)
         return Response(serializer.data)
+
+
+class PartnerAuthInfoViewSet(
+    mixins.CreateModelMixin,
+    viewsets.GenericViewSet,
+):
+    queryset = PartnerAuthInfo.objects.all()
+    permission_classes = [
+        permissions.IsAuthenticated,
+    ]
+
+    @swagger_auto_schema(
+        operation_summary="Send an OTP for PartnerAuthInfo",
+        operation_description="""
+                Send an OTP for PartnerAuthInfo
+            """,
+        tags=[
+            "Partner",
+        ],
+    )
+    @action(
+        methods=[
+            "POST",
+        ],
+        detail=False,
+        url_path="send-otp",
+        serializer_class=PartnerOTPRequestSerializer,
+    )
+    def send_otp(
+        self, request: Request, *args: typing.Any, **kwargs: typing.Any
+    ) -> Response:
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        serializer.save()
+        headers = self.get_success_headers(serializer.data)
+        return Response(
+            {"result": "ok"}, status=status.HTTP_201_CREATED, headers=headers
+        )
+
+    @swagger_auto_schema(
+        operation_summary="verify Partner's Authentication ",
+        operation_description="""
+                verify Partner's Authentication for different auth methods
+            """,
+        tags=[
+            "Partner",
+        ],
+    )
+    @action(
+        methods=[
+            "POST",
+        ],
+        detail=False,
+        url_path="",
+        serializer_class=PartnerAuthInfoSerializer,
+    )
+    def verify(
+        self, request: Request, *args: typing.Any, **kwargs: typing.Any
+    ) -> Response:
+        serializer = self.get_serializer(data=request.data)
+        serializer.is_valid(raise_exception=True)
+        serializer.save()
+        headers = self.get_success_headers(serializer.data)
+        return Response(
+            serializer.data, status=status.HTTP_201_CREATED, headers=headers
+        )

ob_dj_store/core/stores/admin.py

@@ -1,4 +1,5 @@
 import typing
+from typing import Any
 
 from django import forms
 from django.contrib import admin
@@ -16,6 +17,7 @@ from ob_dj_store.core.stores.admin_inlines import (
     OpeningHoursInlineAdmin,
     OrderHistoryInlineAdmin,
     OrderItemInline,
+    PartnerEmailDomainInlineAdmin,
     PhoneContactInlineAdmin,
     ProductAttributeInlineAdmin,
     ProductMediaInlineAdmin,
@@ -386,6 +388,11 @@ class WalletTransactionAdmin(ImportExportModelAdmin, admin.ModelAdmin):
     def user(self, obj) -> typing.Text:
         return obj.wallet.user.email
 
+    def save_model(self, request: Any, obj: Any, form: Any, change: Any) -> None:
+        if not obj.pk:
+            obj.is_by_admin = True
+        return super().save_model(request, obj, form, change)
+
 
 class WalletAdmin(admin.ModelAdmin):
     list_display = ("id", "user", "balance", "currency")
@@ -402,6 +409,35 @@ class AvailabilityHoursAdmin(admin.ModelAdmin):
     list_display = ("id", "store", "category", "from_hour", "to_hour")
 
 
+# Partner Admins
+class PartnerAdmin(admin.ModelAdmin):
+    list_display = ("name", "auth_method", "country", "discount", "promotion_code")
+    search_fields = ["name", "country", "domains__email_domain"]
+    list_filter = ["discount", "auth_method"]
+    inlines = [
+        PartnerEmailDomainInlineAdmin,
+    ]
+
+
+class DiscountAdmin(admin.ModelAdmin):
+    list_display = ("id", "discount_rate", "is_active")
+
+
+class PartnerAuthInfoAdmin(admin.ModelAdmin):
+    list_display = (
+        "id",
+        "user",
+        "email",
+        "partner",
+        "authentication_expires",
+        "created_at",
+    )
+    search_fields = ["email", "user__email", "partner__name"]
+    list_filter = [
+        "authentication_expires",
+    ]
+
+
 admin.site.register(models.Store, StoreAdmin)
 admin.site.register(models.ShippingMethod, ShippingMethodAdmin)
 admin.site.register(models.PaymentMethod, PaymentMethodAdmin)
@@ -422,3 +458,6 @@ admin.site.register(models.Wallet, WalletAdmin)
 admin.site.register(models.WalletMedia, WalletMediaAdmin)
 admin.site.register(models.AvailabilityHours, AvailabilityHoursAdmin)
 admin.site.register(models.Menu, MenuAdmin)
+admin.site.register(models.Partner, PartnerAdmin)
+admin.site.register(models.Discount, DiscountAdmin)
+admin.site.register(models.PartnerAuthInfo, PartnerAuthInfoAdmin)

ob_dj_store/core/stores/admin_inlines.py

@@ -118,3 +118,8 @@ class OrderItemInline(admin.TabularInline):
 class InventoryOperationInlineAdmin(admin.TabularInline):
     model = models.InventoryOperations
     extra = 1
+
+
+class PartnerEmailDomainInlineAdmin(admin.TabularInline):
+    model = models.PartnerEmailDomain
+    extra = 1

ob_dj_store/core/stores/managers.py

@@ -6,6 +6,7 @@ from decimal import Decimal
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.db import models
+from django.utils.timezone import now
 from django.utils.translation import gettext_lazy as _
 
 from config import settings
@@ -63,7 +64,7 @@ class PaymentManager(models.Manager):
                 {"order", _("You cannot perform payment without items")}
             )
         try:
-            if orders[0].store:
+            if orders[0].store and orders[0].type_of_order == "PHYSICAL":
                 kwargs["payment_tax"] = Tax.objects.get(
                     country=orders[0].store.address.country, is_active=True
                 )
@@ -150,7 +151,21 @@ class OrderManager(models.Manager):
         from ob_dj_store.apis.stores.rest.serializers.serializers import (
             OrderDataSerializer,
         )
+        from ob_dj_store.core.stores.models._partner import PartnerAuthInfo
 
+        try:
+            partner_auth_info = PartnerAuthInfo.objects.get(
+                user=kwargs["customer"],
+                authentication_expires__gte=now(),
+                partner__offer_start_time__lte=now(),
+                partner__offer_end_time__gt=now(),
+            )
+        except ObjectDoesNotExist:
+            partner_auth_info = None
+        if partner_auth_info:
+            partner = partner_auth_info.partner
+            if partner.stores.filter(pk=kwargs["store"].pk).exists():
+                kwargs["discount"] = partner.discount
         order = super().create(**kwargs)
         serializer = OrderDataSerializer(order)
         order.init_data = serializer.data
@@ -254,3 +269,8 @@ class WalletTransactionManager(models.Manager):
         if type == WalletTransaction.TYPE.DEBIT and wallet.balance < kwargs["amount"]:
             raise ValidationError(_("Insufficient Funds"))
         return super().create(*args, **kwargs)
+
+
+class PartnerAuthInfoManager(models.Manager):
+    def create(self, *args, **kwargs):
+        return super().create(*args, **kwargs)

ob_dj_store/core/stores/migrations/0089_discount_partner_partnerauthinfo_partneremaildomain_partnerotpauth.py

@@ -0,0 +1,208 @@
+# Generated by Django 3.2.8 on 2023-10-04 11:14
+
+import django.core.validators
+import django.db.models.deletion
+import django_countries.fields
+from django.conf import settings
+from django.db import migrations, models
+
+import ob_dj_store.utils.model
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("otp", "0004_onetruepairing_meta"),
+        ("stores", "0088_alter_paymentmethod_payment_provider"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Discount",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "discount_rate",
+                    models.DecimalField(
+                        decimal_places=2,
+                        max_digits=3,
+                        validators=[
+                            django.core.validators.MaxValueValidator(limit_value=1)
+                        ],
+                    ),
+                ),
+                ("is_active", models.BooleanField(default=True)),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+            ],
+        ),
+        migrations.CreateModel(
+            name="Partner",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "name",
+                    models.CharField(max_length=255, verbose_name="Partner's Name"),
+                ),
+                (
+                    "promotion_code",
+                    models.PositiveBigIntegerField(
+                        blank=True, null=True, verbose_name="Promotion code"
+                    ),
+                ),
+                (
+                    "auth_method",
+                    models.CharField(
+                        choices=[
+                            ("OTP", "One True Pairing"),
+                            ("CODE", "Promotion code"),
+                        ],
+                        max_length=255,
+                        verbose_name="Authentication method",
+                    ),
+                ),
+                (
+                    "country",
+                    django_countries.fields.CountryField(
+                        help_text="Partner's country.", max_length=2
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "discount",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.PROTECT,
+                        related_name="partners",
+                        to="stores.discount",
+                    ),
+                ),
+            ],
+            bases=(ob_dj_store.utils.model.DjangoModelCleanMixin, models.Model),
+        ),
+        migrations.CreateModel(
+            name="PartnerOTPAuth",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "email",
+                    models.EmailField(max_length=254, verbose_name="Partner's Email"),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "otp",
+                    models.OneToOneField(
+                        on_delete=django.db.models.deletion.PROTECT,
+                        to="otp.onetruepairing",
+                    ),
+                ),
+                (
+                    "partner",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="otp_auths",
+                        to="stores.partner",
+                    ),
+                ),
+                (
+                    "user",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="PartnerEmailDomain",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("email_domain", models.CharField(max_length=255)),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "partner",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="domains",
+                        to="stores.partner",
+                    ),
+                ),
+            ],
+            bases=(ob_dj_store.utils.model.DjangoModelCleanMixin, models.Model),
+        ),
+        migrations.CreateModel(
+            name="PartnerAuthInfo",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "email",
+                    models.EmailField(max_length=254, verbose_name="Partner's Email"),
+                ),
+                ("authentication_details", models.JSONField(blank=True, null=True)),
+                ("authentication_expires", models.DateTimeField()),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                (
+                    "updated_at",
+                    models.DateTimeField(
+                        auto_now=True, verbose_name="Last Authentifacation"
+                    ),
+                ),
+                (
+                    "partner",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE, to="stores.partner"
+                    ),
+                ),
+                (
+                    "user",
+                    models.OneToOneField(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+        ),
+    ]

ob_dj_store/core/stores/migrations/0090_auto_20231006_1356.py

@@ -0,0 +1,32 @@
+# Generated by Django 3.2.8 on 2023-10-06 10:56
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("otp", "0004_onetruepairing_meta"),
+        (
+            "stores",
+            "0089_discount_partner_partnerauthinfo_partneremaildomain_partnerotpauth",
+        ),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="favorite",
+            name="extra_info",
+            field=models.TextField(blank=True, null=True),
+        ),
+        migrations.AlterField(
+            model_name="partnerotpauth",
+            name="otp",
+            field=models.OneToOneField(
+                on_delete=django.db.models.deletion.PROTECT,
+                related_name="partner_otp_auth",
+                to="otp.onetruepairing",
+            ),
+        ),
+    ]

ob_dj_store/core/stores/migrations/0091_auto_20231010_1740.py

@@ -0,0 +1,30 @@
+# Generated by Django 3.2.8 on 2023-10-10 14:40
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("stores", "0090_auto_20231006_1356"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="partner",
+            name="stores",
+            field=models.ManyToManyField(related_name="partners", to="stores.Store"),
+        ),
+        migrations.AlterField(
+            model_name="partner",
+            name="promotion_code",
+            field=models.PositiveBigIntegerField(
+                blank=True, null=True, unique=True, verbose_name="Promotion code"
+            ),
+        ),
+        migrations.AlterField(
+            model_name="partneremaildomain",
+            name="email_domain",
+            field=models.CharField(max_length=255, unique=True),
+        ),
+    ]

ob_dj_store/core/stores/migrations/0092_auto_20231012_1339.py

@@ -0,0 +1,47 @@
+# Generated by Django 3.2.8 on 2023-10-12 10:39
+
+import django.db.models.deletion
+import django.utils.timezone
+from django.db import migrations, models
+
+import ob_dj_store.core.stores.models._partner
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("stores", "0091_auto_20231010_1740"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="order",
+            name="discount",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.PROTECT,
+                to="stores.discount",
+            ),
+        ),
+        migrations.AddField(
+            model_name="partner",
+            name="offer_end_time",
+            field=models.DateTimeField(
+                default=ob_dj_store.core.stores.models._partner.default_offer_end_time,
+                verbose_name="Offer end date",
+            ),
+        ),
+        migrations.AddField(
+            model_name="partner",
+            name="offer_start_time",
+            field=models.DateTimeField(
+                default=django.utils.timezone.now, verbose_name="Offer start date"
+            ),
+        ),
+        migrations.AddField(
+            model_name="wallettransaction",
+            name="is_by_admin",
+            field=models.BooleanField(default=False),
+        ),
+    ]

ob_dj_store/core/stores/models/__init__.py

@@ -8,6 +8,13 @@ from ob_dj_store.core.stores.models._feedback import (
 )
 from ob_dj_store.core.stores.models._inventory import Inventory, InventoryOperations
 from ob_dj_store.core.stores.models._order import Order, OrderHistory, OrderItem
+from ob_dj_store.core.stores.models._partner import (
+    Discount,
+    Partner,
+    PartnerAuthInfo,
+    PartnerEmailDomain,
+    PartnerOTPAuth,
+)
 from ob_dj_store.core.stores.models._payment import Payment, Tax
 from ob_dj_store.core.stores.models._product import (
     Attribute,
@@ -71,4 +78,9 @@ __all__ = [
     "AvailabilityHours",
     "StoreAttributeChoice",
     "Menu",
+    "PartnerEmailDomain",
+    "Partner",
+    "PartnerAuthInfo",
+    "PartnerOTPAuth",
+    "Discount",
 ]

ob_dj_store/core/stores/models/_cart.py

@@ -3,9 +3,11 @@ from decimal import Decimal
 from django.contrib.auth import get_user_model
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.db import models
+from django.utils.timezone import now
 from django.utils.translation import gettext_lazy as _
 
 from ob_dj_store.core.stores.managers import CartItemManager, CartManager
+from ob_dj_store.core.stores.models._partner import PartnerAuthInfo
 
 
 class Cart(models.Model):
@@ -43,6 +45,27 @@ class Cart(models.Model):
     def total_price_with_tax(self) -> Decimal:
         return self.total_price + self.tax_amount
 
+    @property
+    def get_user_partner(self):
+        try:
+            partner_auth_info = PartnerAuthInfo.objects.get(
+                user=self.customer,
+                authentication_expires__gte=now(),
+                partner__offer_start_time__lte=now(),
+                partner__offer_end_time__gt=now(),
+            )
+            return partner_auth_info.partner
+        except ObjectDoesNotExist:
+            return None
+
+    @property
+    def discount_offer_amount(self):
+        return sum(map(lambda item: item.discount_amount, self.items.all()))
+
+    @property
+    def total_price_with_discount(self):
+        return self.total_price - self.discount_offer_amount
+
     def __str__(self):
         return f"Cart - {self.customer.email} with total price {self.total_price}"
 
@@ -124,6 +147,14 @@ class CartItem(models.Model):
                 pass
         return 0
 
+    @property
+    def discount_amount(self):
+        partner = self.cart.get_user_partner
+        if partner:
+            if partner.discount and partner.stores.filter(pk=self.store.pk).exists():
+                return partner.discount.perc_to_flat(self.total_price)
+        return Decimal(0)
+
     @property
     def attribute_choices_total_price(self) -> Decimal:
         total_price = Decimal(0)

ob_dj_store/core/stores/models/_favorite.py

@@ -20,6 +20,7 @@ class Favorite(DjangoModelCleanMixin, models.Model):
     content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
     content_object = GenericForeignKey("content_type", "object_id")
     object_id = models.PositiveIntegerField()
+    extra_info = models.TextField(blank=True, null=True)
     # Audit fields
     created_on = models.DateTimeField(auto_now_add=True)
     objects = FavoriteManager()
@@ -33,13 +34,14 @@ class Favorite(DjangoModelCleanMixin, models.Model):
         return f"{self.user} favorites {self.content_object}"
 
     @classmethod
-    def add_favorite(cls, content_object, user, name, extras=[]):
+    def add_favorite(cls, content_object, user, name, extra_info=None, 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,
+            extra_info=extra_info,
             name=name,
         )
         favorite.save()
@@ -52,10 +54,12 @@ class Favorite(DjangoModelCleanMixin, models.Model):
             )
         return favorite
 
-    def update_favorite(self, name, extras=[]):
+    def update_favorite(self, name, extra_info=None, extras=[]):
         from ob_dj_store.core.stores.models._favorite import FavoriteExtra
 
         self.name = name
+        if extra_info:
+            self.extra_info = extra_info
         self.save()
         FavoriteExtra.objects.filter(favorite=self).delete()
         for extra in extras:

ob_dj_store/core/stores/models/_order.py

@@ -37,6 +37,9 @@ class Order(DjangoModelCleanMixin, models.Model):
     # TODO: Probably we want to setup the on_delete to SET_NULL because orders is part of
     #       sales and even if a user deleted orders cannot disappear otherwise will reflect
     #       invalid sales figure; same can be applied for the store field
+    discount = models.ForeignKey(
+        "stores.Discount", on_delete=models.PROTECT, null=True, blank=True
+    )
     customer = models.ForeignKey(
         get_user_model(),
         related_name="orders",
@@ -126,6 +129,10 @@ class Order(DjangoModelCleanMixin, models.Model):
         self.status = Order.OrderStatus.READY
         self.save()
 
+    @property
+    def get_discount_amount(self):
+        return sum(map(lambda item: item.discount_offer_amount, self.items.all()))
+
     @property
     def total_amount(self):
         if self.type_of_order == Order.OrderType.WALLET.value:
@@ -137,6 +144,7 @@ class Order(DjangoModelCleanMixin, models.Model):
         )
         if self.shipping_method:
             amount += self.shipping_method.shipping_fee
+        amount -= self.get_discount_amount
         return amount
 
     @property
@@ -211,6 +219,13 @@ class OrderItem(DjangoModelCleanMixin, models.Model):
             total_price += attribute_choice.price
         return total_price
 
+    @property
+    def discount_offer_amount(self):
+        discount = self.order.discount
+        if discount:
+            return discount.perc_to_flat(self.total_amount)
+        return Decimal(0)
+
     @property
     def total_amount(self):
         if self.total_price > 0:

ob_dj_store/core/stores/models/_partner.py

@@ -0,0 +1,116 @@
+import logging
+from datetime import timedelta
+
+from django.conf import settings
+from django.core.validators import MaxValueValidator
+from django.db import models
+from django.utils.timezone import now
+from django.utils.translation import gettext_lazy as _
+from django_countries.fields import CountryField
+from ob_dj_otp.core.otp.models import OneTruePairing
+
+from ob_dj_store.core.stores.managers import PartnerAuthInfoManager
+from ob_dj_store.core.stores.models._store import Store
+from ob_dj_store.utils.model import DjangoModelCleanMixin
+
+logger = logging.getLogger(__name__)
+
+
+class Discount(models.Model):
+    discount_rate = models.DecimalField(
+        max_digits=3, decimal_places=2, validators=[MaxValueValidator(limit_value=1)]
+    )
+    is_active = models.BooleanField(default=True)
+
+    # Audit fields
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self) -> str:
+        return f"{self.discount_rate * 100}% Discount"
+
+    def perc_to_flat(self, amount):
+        return amount * self.discount_rate
+
+
+def default_offer_end_time():
+    return now() + timedelta(days=getattr(settings, "DEFAULT_PARTNER_OFFER_TIME", 60))
+
+
+class Partner(DjangoModelCleanMixin, models.Model):
+    class AuthMethods(models.TextChoices):
+        OTP = "OTP", _("One True Pairing")
+        CODE = "CODE", _("Promotion code")
+
+    name = models.CharField(_("Partner's Name"), max_length=255)
+    stores = models.ManyToManyField(Store, related_name="partners")
+    promotion_code = models.PositiveBigIntegerField(
+        _("Promotion code"), null=True, blank=True, unique=True
+    )
+    auth_method = models.CharField(
+        _("Authentication method"), max_length=255, choices=AuthMethods.choices
+    )
+    country = CountryField(help_text=_("Partner's country."))
+    discount = models.ForeignKey(
+        Discount, on_delete=models.PROTECT, related_name="partners"
+    )
+    offer_start_time = models.DateTimeField(_("Offer start date"), default=now)
+    offer_end_time = models.DateTimeField(
+        _("Offer end date"), default=default_offer_end_time
+    )
+
+    # Audit fields
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self) -> str:
+        return f"{self.name}"
+
+
+class PartnerEmailDomain(DjangoModelCleanMixin, models.Model):
+    partner = models.ForeignKey(
+        Partner, on_delete=models.CASCADE, related_name="domains"
+    )
+    email_domain = models.CharField(max_length=255, unique=True)
+
+    # Audit fields
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+
+class PartnerAuthInfo(models.Model):
+    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
+    email = models.EmailField(_("Partner's Email"))
+    partner = models.ForeignKey(Partner, on_delete=models.CASCADE)
+    authentication_details = models.JSONField(null=True, blank=True)
+    authentication_expires = models.DateTimeField()
+
+    # Audit fields
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(_("Last Authentifacation"), auto_now=True)
+
+    objects = PartnerAuthInfoManager()
+
+    def save(self, **kwargs) -> None:
+        self.authentication_expires = now() + timedelta(
+            days=getattr(settings, "PARTNER_AUTH_TIME", 365)
+        )
+        return super().save(**kwargs)
+
+
+class PartnerOTPAuth(models.Model):
+    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
+    otp = models.OneToOneField(
+        OneTruePairing, on_delete=models.PROTECT, related_name="partner_otp_auth"
+    )
+    partner = models.ForeignKey(
+        Partner, on_delete=models.CASCADE, related_name="otp_auths"
+    )
+    email = models.EmailField(_("Partner's Email"))
+
+    # Audit fields
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self) -> str:
+        return f"PartnerOTPAuth(PK={self.pk})"

ob_dj_store/core/stores/models/_wallet.py

@@ -161,6 +161,7 @@ class WalletTransaction(models.Model):
         decimal_places=settings.DEFAULT_DECIMAL_PLACES,
     )
 
+    is_by_admin = models.BooleanField(default=False)
     is_cashback = models.BooleanField(default=False)
     is_refund = models.BooleanField(default=False)
 

ob_dj_store/core/stores/utils.py

@@ -1,9 +1,13 @@
 import math
+from datetime import timedelta
 
 import pycountry
 from django.core.exceptions import ValidationError
+from django.utils.timezone import now
 from django.utils.translation import gettext_lazy as _
 
+from config import settings
+
 
 def get_data_dict(instance):
     """
@@ -53,10 +57,13 @@ def distance(origin, destination):
     return d
 
 
-def get_currency_by_country(country):
-    country = pycountry.countries.get(name=country)
-    currency = pycountry.currencies.get(numeric=country.numeric)
-    return currency.alpha_3
+def get_currency_by_country(country_value):
+    try:
+        country = pycountry.countries.get(alpha_2=country_value)
+        currency = pycountry.currencies.get(numeric=country.numeric)
+        return currency.alpha_3
+    except Exception as e:
+        return None
 
 
 def get_country_by_currency(currency):
@@ -71,3 +78,23 @@ def validate_currency(value):
             _("%(value)s is not a currency"),
             params={"value": value},
         )
+
+
+class PartnerAuth:
+    def __init__(self, email: str):
+        from ob_dj_store.core.stores.models import PartnerAuthInfo, PartnerEmailDomain
+
+        try:
+            domain = PartnerEmailDomain.objects.get(email_domain=email.split("@")[1])
+            self.partner = domain.partner
+        except PartnerEmailDomain.DoesNotExist:
+            raise ValidationError(_("Domain doesn't exist"))
+
+        # verify email availability
+        renew_time = now() + timedelta(
+            hours=getattr(settings, "PARTNER_RENEW_AUTH_TIME", 24)
+        )
+        if PartnerAuthInfo.objects.filter(
+            email=email, authentication_expires__gt=renew_time
+        ).exists():
+            raise ValidationError(_("This email is already in use"))

{ob_dj_store-0.0.15.18.dist-info → ob_dj_store-0.0.16.1.dist-info}/METADATA

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

{ob_dj_store-0.0.15.18.dist-info → ob_dj_store-0.0.16.1.dist-info}/RECORD

@@ -1,22 +1,22 @@
 ob_dj_store/apis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ob_dj_store/apis/stores/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ob_dj_store/apis/stores/filters.py,sha256=7tp_KUaiTWkFQaFQnePU4eXrOMhbY7oN6SRjr90czzM,8672
-ob_dj_store/apis/stores/urls.py,sha256=P4d0iamg2R5lTwc5DTIuhLzJTMSH4f5QpHzGR1_PWE0,1676
-ob_dj_store/apis/stores/views.py,sha256=v-WZCpvY3Y9N3rmC6bG3R2NrhikFUDLey5KzaShwgs4,38160
-ob_dj_store/apis/stores/rest/serializers/serializers.py,sha256=dGteCoIqCDcrOVGsdjseJgIB1w5EP6q4XJvgUD8fhBQ,49772
+ob_dj_store/apis/stores/filters.py,sha256=cWEIriaBil5iJlnTgFPMYJtyaHNcI3x3EoQ5X12lkCI,8927
+ob_dj_store/apis/stores/urls.py,sha256=xL7CUNJDqxWzb8Gt7gYH63rmQ00rfGoTr9duiu9-0v8,1778
+ob_dj_store/apis/stores/views.py,sha256=llLsupgQ-Rq9KqeE0ajNq7Lpj7bIDkvPN7cbhsd3Nn4,40134
+ob_dj_store/apis/stores/rest/serializers/serializers.py,sha256=5nlrfs9l0rfb1Ai7rKcWrfpKAbiGF_xI3R8Bk2MB-Go,55919
 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
 ob_dj_store/apis/tap/views.py,sha256=VnVquybTHlJquxsC0RNTy20dtLXalchO0SlGjSDaBng,2666
 ob_dj_store/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ob_dj_store/core/stores/__init__.py,sha256=-izNGrxNn_nn3IQXd5pkuES9lSF-AHYb14yhNPozYCI,65
-ob_dj_store/core/stores/admin.py,sha256=jMYG6vQ2BZJFT_4uqPoAwAJDAonbPLurz8mbsPpF3gA,10522
-ob_dj_store/core/stores/admin_inlines.py,sha256=K7T5IqTqkCKzt_8vqAg3OqOuREqih_lujf1ULB1YFS8,2791
+ob_dj_store/core/stores/admin.py,sha256=klnZPKa5BR0yBqTKAYlJJys5RqpG9V4bLEXNI34h8mI,11680
+ob_dj_store/core/stores/admin_inlines.py,sha256=NM8Ab7htloQdihRBmew4Ie-ENsKhMlKRIsIH06xO1Mw,2903
 ob_dj_store/core/stores/apps.py,sha256=ZadmEER_dNcQTH617b3fAsYZJSyRw0g46Kjp4eOAsOU,498
-ob_dj_store/core/stores/managers.py,sha256=NWYR4x3bCnmkrS0J5vtfpH9Q-VEWSSmvMuGM9xYIlSg,8699
+ob_dj_store/core/stores/managers.py,sha256=DeO8wlN7YvbVZvKZWt5Z4aDgcip54vCioCZH-IRQhuY,9548
 ob_dj_store/core/stores/receivers.py,sha256=DljYC97C_e1mHduKw9Un6YQmxIdwSIter7yVVZwggFA,3768
 ob_dj_store/core/stores/settings_validation.py,sha256=eTkRaI6CG5OEJQyI5CF-cNAcvjzXf3GwX5sR97O3v98,3977
-ob_dj_store/core/stores/utils.py,sha256=_FwZEIwKdfj3CuYHCz3wKqq5TBb8xak7UiiCB1oggKc,1850
+ob_dj_store/core/stores/utils.py,sha256=70cE4mf64KiEdh5yYhUfLIqykH2MbnN9xlvNgEx5Mk0,2775
 ob_dj_store/core/stores/gateway/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ob_dj_store/core/stores/gateway/tap/__init__.py,sha256=5Z6azpb6tmr1nRvKwQWzlYw9ruvw-9ZMBWRqEngDKTM,40
 ob_dj_store/core/stores/gateway/tap/admin.py,sha256=3KgawxLjvpMsYXl_hx1DlKYpsMd-ojSA4FNazVA4CIk,1183
@@ -120,23 +120,28 @@ ob_dj_store/core/stores/migrations/0085_auto_20230726_1528.py,sha256=inhGNw0kttc
 ob_dj_store/core/stores/migrations/0086_wallet_is_active.py,sha256=wS5H-i1BvbzpuqhtfUZ08CPGAH5X0W8Z8oEnPJ87RCQ,388
 ob_dj_store/core/stores/migrations/0087_auto_20230828_2138.py,sha256=ESHEN8RnSQh_WzsfVhwqdPO5pnSwtRhtWRT2gsUB5ZY,1785
 ob_dj_store/core/stores/migrations/0088_alter_paymentmethod_payment_provider.py,sha256=SuZ2YFSPaZB2O54jP7U31NH2JD5tKmyR0kalLIuAvQ8,932
+ob_dj_store/core/stores/migrations/0089_discount_partner_partnerauthinfo_partneremaildomain_partnerotpauth.py,sha256=c8IbAcCLkxw0ttI0UQxWkY0ZyBOD_AUDRn6dSXNshLA,7374
+ob_dj_store/core/stores/migrations/0090_auto_20231006_1356.py,sha256=wJGLZDhri35X_Tr72gYrzZP6EEuz3qiKRN9BDsmLfCU,871
+ob_dj_store/core/stores/migrations/0091_auto_20231010_1740.py,sha256=qUjN-qPM3k19dLpG42tEPePacFTTWvussGtsgetBNEU,862
+ob_dj_store/core/stores/migrations/0092_auto_20231012_1339.py,sha256=KzINBlngxNmU-dQjV5VgZssVL6jihxY7jbMfpfDN5K4,1367
 ob_dj_store/core/stores/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ob_dj_store/core/stores/models/__init__.py,sha256=gQGy9jDRGxMH_T6Bc8_utYbx-G8BNAG4SqqghkXOcPc,1741
+ob_dj_store/core/stores/models/__init__.py,sha256=vG1vVOXne3Gg938-015MGrXQAaxqVLYF0Amd85oKrhY,1991
 ob_dj_store/core/stores/models/_address.py,sha256=qS5TQ9Z12zx_4CrrHvG8PoYVkdiOq_MtbKR14WKh3Hw,1661
-ob_dj_store/core/stores/models/_cart.py,sha256=SmlOczSZ2UnEIFcCR107-pcCMlkOL0oWb22h6--x_1k,4779
-ob_dj_store/core/stores/models/_favorite.py,sha256=J29ECDsotIgduPpmUmieYTndymReWHkfdsZyQzz6A4g,3042
+ob_dj_store/core/stores/models/_cart.py,sha256=9JYfu-T0_AZiZEY8vaHJ719L4zqVOgvMXj3sj-dixtE,5856
+ob_dj_store/core/stores/models/_favorite.py,sha256=ZVFCsDWB8fOcx5LkhNphTNRGuEUdsHM0ex1-OtFa4gA,3232
 ob_dj_store/core/stores/models/_feedback.py,sha256=eCUVgprNK5hSRKOS4M_pdR7QH2-rqhoYevlpykhCOLg,1472
 ob_dj_store/core/stores/models/_inventory.py,sha256=ZU8xDMQZxLnFehkBEGWr-os4AF1IlCn5XnBxvRq9IAs,4314
-ob_dj_store/core/stores/models/_order.py,sha256=VHBp3LMveedHNbS7vxP7PE_H_g9t8qgsi7_szQIlBB8,8650
+ob_dj_store/core/stores/models/_order.py,sha256=am-tpHs0b4mu5xdj5xaK3LQjhGs88aKNyhLFX8g8XA4,9139
+ob_dj_store/core/stores/models/_partner.py,sha256=N4nc7FUWBkkkBar6__nJ2Jg1SxOBnt1YCnsLaKpa_vk,4057
 ob_dj_store/core/stores/models/_payment.py,sha256=mz54fuxmcNQ1pVBC959f7gnbIld1haxIYK0Xuv6UVoM,6320
 ob_dj_store/core/stores/models/_product.py,sha256=jWbhk-oXngLdHqBTnHNokzN_MhcBArsD1R7UjOnfAzY,15287
 ob_dj_store/core/stores/models/_store.py,sha256=NnyXG7_L_UYrNKaQYuHOBEWc6DQqAPd1OZJg0xOccKk,8005
-ob_dj_store/core/stores/models/_wallet.py,sha256=8wi-H0HMFOdDPc1LbKkQBMGAymiLvBWq2djnN_BicRI,5327
+ob_dj_store/core/stores/models/_wallet.py,sha256=0Ap6CYGFC0IJ9nfgPU1ypDq3r9HQjI5L9J8vz6FE7Es,5380
 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.15.18.dist-info/METADATA,sha256=_TNqQ5SliuR9Wz_0YVpKFKPu4V9ziwbLaTnwWyvCIfk,2828
-ob_dj_store-0.0.15.18.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-ob_dj_store-0.0.15.18.dist-info/top_level.txt,sha256=CZG3G0ptTkzGnc0dFYN-ZD7YKdJBmm47bsmGwofD_lk,12
-ob_dj_store-0.0.15.18.dist-info/RECORD,,
+ob_dj_store-0.0.16.1.dist-info/METADATA,sha256=0NDzIbqnGaB5C25MeBZobX2rD72RhbgXpI_UGy6y3OI,2827
+ob_dj_store-0.0.16.1.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+ob_dj_store-0.0.16.1.dist-info/top_level.txt,sha256=CZG3G0ptTkzGnc0dFYN-ZD7YKdJBmm47bsmGwofD_lk,12
+ob_dj_store-0.0.16.1.dist-info/RECORD,,