ob-dj-store 0.0.12__tar.gz → 0.0.12.2__tar.gz

{ob-dj-store-0.0.12 → ob-dj-store-0.0.12.2}/PKG-INFO

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

{ob-dj-store-0.0.12 → ob-dj-store-0.0.12.2}/config/settings.py

@@ -356,9 +356,33 @@ DIGITAL_PRODUCTS_REQUIRED_KEYS = (
 
 
 # Favorite Settings
+MULTIPLE_FAVORITE_EXTRA = 1
+SIGNLE_FAVORITE_EXTRA = 0
+FAVORITE_TYPES = {
+    "Store": {
+        "path": "ob_dj_store.core.stores.models._store.Store",
+    },
+    "Product": {
+        "path": "ob_dj_store.core.stores.models._product.Product",
+        "extras": {
+            "AttributeChoice": {
+                "path": "ob_dj_store.core.stores.models._product.AttributeChoice",
+                "type": MULTIPLE_FAVORITE_EXTRA,
+            },
+            "ProductVariant": {
+                "path": "ob_dj_store.core.stores.models._product.ProductVariant",
+                "type": SIGNLE_FAVORITE_EXTRA,
+            },
+        },
+    },
+}
+FAVORITES_SERIALIZERS_PATHS = {
+    "Product": "ob_dj_store.apis.stores.rest.serializers.serializers.ProductSerializer",
+    "Store": "ob_dj_store.apis.stores.rest.serializers.serializers.StoreSerializer",
+    "AttributeChoice": "ob_dj_store.apis.stores.rest.serializers.serializers.AttributeChoiceSerializer",
+    "ProductVariant": "ob_dj_store.apis.stores.rest.serializers.serializers.ProductVariantSerializer",
+}
 
-FAVORITE_TYPES = ("Store", "Product")
-EXTRA_FAVORITE_TYPES = ("AttributeChoice",)
 
 ESTIMATED_DELIVERING_TIME = 10  # in minutes
 DIFFERENT_STORE_ORDERING = False

{ob-dj-store-0.0.12 → ob-dj-store-0.0.12.2}/ob_dj_store/apis/stores/rest/serializers/serializers.py

@@ -1,5 +1,4 @@
 import calendar
-import sys
 import typing
 from datetime import time, timedelta
 
@@ -7,7 +6,9 @@ from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.gis.geos import Point
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
+from django.db import models
 from django.shortcuts import get_object_or_404
+from django.utils.module_loading import import_string
 from django.utils.timezone import now
 from django.utils.translation import gettext_lazy as _
 from rest_framework import serializers
@@ -963,18 +964,25 @@ class GenericSerializer(serializers.Serializer):
         return serializer_class(context=context).to_representation(value)
 
     def get_serializer_for_instance(self, instance):
-        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"))
+        serializer_class = instance.__class__.__name__
+        return import_string(
+            store_settings.FAVORITES_SERIALIZERS_PATHS[serializer_class]
+        )
+
+
+def get_favorite_extras_models():
+    extras_list = []
+    for key, value in settings.FAVORITE_TYPES.items():
+        if "extras" in value:
+            extras_list.extend(value["extras"].keys())
+    return extras_list
 
 
 class FavoriteExtraSerializer(serializers.ModelSerializer):
     content_object = GenericSerializer(read_only=True)
     object_id = serializers.IntegerField(min_value=1, write_only=True)
     object_type = serializers.ChoiceField(
-        write_only=True, choices=store_settings.EXTRA_FAVORITE_TYPES
+        write_only=True, choices=get_favorite_extras_models()
     )
 
     class Meta:
@@ -986,13 +994,23 @@ class FavoriteExtraSerializer(serializers.ModelSerializer):
             "object_type",
         )
 
+    def to_representation(self, instance):
+        data = super().to_representation(instance)
+        extras = get_favorite_extras_models()
+        model_name = instance.content_type.model
+        for extra in extras:
+            if model_name == extra.lower():
+                data["object_type"] = extra
+                break
+        return data
+
 
 class FavoriteSerializer(serializers.ModelSerializer):
     content_object = GenericSerializer(read_only=True)
     extras = FavoriteExtraSerializer(many=True)
     object_id = serializers.IntegerField(min_value=1, write_only=True)
     object_type = serializers.ChoiceField(
-        write_only=True, choices=store_settings.FAVORITE_TYPES
+        write_only=True, choices=list(store_settings.FAVORITE_TYPES.keys())
     )
 
     class Meta:
@@ -1009,63 +1027,87 @@ class FavoriteSerializer(serializers.ModelSerializer):
             "name": {"required": True},
         }
 
+    def to_representation(self, instance):
+        data = super().to_representation(instance)
+        model_name = instance.content_type.model
+        for favorite in store_settings.FAVORITE_TYPES.keys():
+            if model_name == favorite.lower():
+                data["object_type"] = favorite
+                break
+        return data
+
     def _lookup_validation(self, data):
-        content_type = ContentType.objects.get_for_model(type(data["content_object"]))
-        extras_lookup_content_type = {}
-        for extra in data["extras"]:
-            content_type_extra = extra.model
-            extras_lookup_content_type[content_type_extra] = extra
+        content_type = ContentType.objects.get_for_model(data["content_object"])
         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(
-                extras__content_type=ContentType.objects.get_for_model(key),
-                extras__object_id__in=[
-                    extra.id for extra in extras_lookup_content_type[key]
-                ],
-            )
-        if queryset.exists():
+        ).prefetch_related("extras")
+
+        if not queryset.exists():
+            return
+
+        for favorite in queryset:
+            content_objects = [
+                instance.content_object for instance in favorite.extras.all()
+            ]
+            if data["extras"] == content_objects:
+                raise serializers.ValidationError(
+                    _(f"You cannot favorite the same item twice")
+                )
+
+    def get_object(self, model: models.Model, id: int):
+        try:
+            object = model.objects.get(pk=id)
+            return object
+        except model.DoesNotExist:
             raise serializers.ValidationError(
-                _(f"You cannot favorite the same item twice")
+                _(f"{model.__name__} with the id of {id} does not exist")
             )
 
     def validate(self, attrs):
         validated_data = super().validate(attrs)
+        extras_data = {}
         name = validated_data["name"]
         object_type = validated_data["object_type"]
-        if object_type not in store_settings.FAVORITE_TYPES and hasattr(
-            sys.modules[__name__], object_type
-        ):
-            raise serializers.ValidationError(
-                _(f"Cannot resolve keyword '{object_type}' into an object type")
-            )
-        object_type_model = getattr(sys.modules[__name__], object_type)
+        object_type_model = import_string(
+            store_settings.FAVORITE_TYPES[object_type]["path"]
+        )
         object_instance = get_object_or_404(
             object_type_model, pk=validated_data["object_id"]
         )
-        extras_data = {}
-        extras = []
         for extra in validated_data["extras"]:
-            extra_object_type = extra["object_type"]
-            if extra_object_type not in store_settings.EXTRA_FAVORITE_TYPES:
+            if (
+                extra["object_type"]
+                not in store_settings.FAVORITE_TYPES[object_type]["extras"]
+            ):
                 raise serializers.ValidationError(
-                    _(
-                        f"Cannot resolve keyword '{extra_object_type}' into an object type"
-                    )
+                    _(f"{extra['object_type']} Cannot be extra of {object_type}")
                 )
-            extras_data.setdefault(extra_object_type, [])
-            extras_data[extra_object_type].append(extra["object_id"])
-        try:
-            for key in extras_data.keys():
-                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."))
+            extra_object_type = extra["object_type"]
+            extras_data.setdefault(
+                extra_object_type,
+                {
+                    "model": import_string(
+                        store_settings.FAVORITE_TYPES[object_type]["extras"][
+                            extra_object_type
+                        ]["path"]
+                    ),
+                    "ids": [],
+                },
+            )
+            extras_data[extra_object_type]["ids"].append(extra["object_id"])
 
+        extras = []
+        for key, value in extras_data.items():
+            type = store_settings.FAVORITE_TYPES[object_type]["extras"][key]["type"]
+            if len(value["ids"]) > 1 and type == store_settings.SIGNLE_FAVORITE_EXTRA:
+                raise serializers.ValidationError(_(f"Cannot set multiple {key}s"))
+            for id in value["ids"]:
+                extras.append(
+                    self.get_object(value["model"], id)
+                )  # get objects of extras instead of ids
+        extras = list(set(extras))  # remove duplicated extras
         validated_data = {
             "content_object": object_instance,
             "extras": extras,

{ob-dj-store-0.0.12 → ob-dj-store-0.0.12.2}/ob_dj_store/core/stores/models/_favorite.py

@@ -44,13 +44,12 @@ class Favorite(DjangoModelCleanMixin, models.Model):
         )
         favorite.save()
         for extra in extras:
-            for obj in extra:
-                extra_content_type = ContentType.objects.get_for_model(type(obj))
-                favorite.extras.create(
-                    content_type=extra_content_type,
-                    object_id=obj.id,
-                    content_object=obj,
-                )
+            extra_content_type = ContentType.objects.get_for_model(type(extra))
+            favorite.extras.create(
+                content_type=extra_content_type,
+                object_id=extra.id,
+                content_object=extra,
+            )
         return favorite
 
 

ob-dj-store-0.0.12.2/ob_dj_store/core/stores/settings_validation.py

@@ -0,0 +1,88 @@
+from django.apps import apps
+from django.core.checks import Error
+from django.utils.module_loading import import_string
+
+from config import settings
+
+REQUIRED_INSTALLED_APPS = [
+    "rest_framework",
+]
+
+
+def required_installed_apps(app_configs, **kwargs):
+    return [
+        Error(f"{app} is required in INSTALLED_APPS")
+        for app in REQUIRED_INSTALLED_APPS
+        if not apps.is_installed(app)
+    ]
+
+
+def store_validation_settings(app_configs, **kwargs):
+    errors = []
+    if getattr(settings, "GIFT", None) and not getattr(
+        settings, "GIFT_PAYMENT_METHOD_PATH", None
+    ):
+        errors.append(
+            Error(
+                "GIFT_PAYMENT_METHOD_PATH must be set if GIFT is in Payment methods",
+                id="store_validation_settings_error",
+            )
+        )
+
+    def _path_validation(path):
+        try:
+            print(path)
+            path_class = import_string(path)
+        except ImportError:
+            errors.append(
+                Error(
+                    f"{path} is not a valid path", id="store_validation_settings_error"
+                )
+            )
+
+    if hasattr(settings, "GIFT_PAYMENT_METHOD_PATH"):
+        _path_validation(settings.GIFT_PAYMENT_METHOD_PATH)
+
+    # Favorite validation settings
+    if hasattr(settings, "FAVORITE_TYPES"):
+        for key, favorite in settings.FAVORITE_TYPES.items():
+            if not favorite.get("path"):
+                errors.append(
+                    Error(
+                        f"Model path should be set for {key}",
+                        id="store_validation_settings_error",
+                    )
+                )
+            else:
+                _path_validation(favorite["path"])
+            if favorite.get("extras", None):
+                for key_extra, extra in favorite["extras"].items():
+                    if not extra.get("path", None):
+                        errors.append(
+                            Error(
+                                f"Model path should be set for {key}",
+                                id="store_validation_settings_error",
+                            )
+                        )
+                    else:
+                        _path_validation(extra["path"])
+                    if extra.get("type", None) == None:
+                        errors.append(
+                            Error(
+                                f"type must be set for {key_extra}",
+                                id="store_validation_settings_error",
+                            )
+                        )
+                    else:
+                        if not (
+                            hasattr(settings, "SIGNLE_FAVORITE_EXTRA")
+                            and hasattr(settings, "MULTIPLE_FAVORITE_EXTRA")
+                        ):
+                            errors.append(
+                                Error(
+                                    f"SIGNLE_FAVORITE_EXTRA and MULTIPLE_FAVORITE_EXTRA must be set",
+                                    id="store_validation_settings_error",
+                                )
+                            )
+
+    return errors

{ob-dj-store-0.0.12 → ob-dj-store-0.0.12.2}/ob_dj_store.egg-info/PKG-INFO

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

ob-dj-store-0.0.12/ob_dj_store/core/stores/settings_validation.py

@@ -1,45 +0,0 @@
-from django.apps import apps
-from django.core.checks import Error
-from django.utils.module_loading import import_string
-
-from config import settings
-
-REQUIRED_INSTALLED_APPS = [
-    "rest_framework",
-]
-
-
-def required_installed_apps(app_configs, **kwargs):
-    return [
-        Error(f"{app} is required in INSTALLED_APPS")
-        for app in REQUIRED_INSTALLED_APPS
-        if not apps.is_installed(app)
-    ]
-
-
-def store_validation_settings(app_configs, **kwargs):
-    errors = []
-    if getattr(settings, "GIFT", None) and not getattr(
-        settings, "GIFT_PAYMENT_METHOD_PATH", None
-    ):
-        errors.append(
-            Error(
-                "GIFT_PAYMENT_METHOD_PATH must be set if GIFT is in Payment methods",
-                id="store_validation_settings_error",
-            )
-        )
-
-    def _path_validation(path):
-        try:
-            print(path)
-            path_class = import_string(path)
-        except ImportError:
-            errors.append(
-                Error(
-                    f"{path} is not a valid path", id="store_validation_settings_error"
-                )
-            )
-
-    if getattr(settings, "GIFT_PAYMENT_METHOD_PATH", None):
-        _path_validation(settings.GIFT_PAYMENT_METHOD_PATH)
-    return errors