#183 object compositions (#194)

* Create catalog.context package

* Create context package

* Specify context ABS classes

* Implement base product contexts classes

* Implement base tag contexts classes

* Resolve todo and create another one for  ordering arg

* Self-review fixes

* Review fixes

* Self-review fixes

catalog/context.py

@@ -306,10 +306,8 @@ def products(self):
             products = (
                 products
                 .filter(tags__in=tags)
-                # Use distinct because filtering by QuerySet tags,
-                # that related with products by many-to-many relation.
-                # @todo #550:60m Try to rm sorting staff from context.TaggedCategory.
-                #  Or explain again why it's impossible. Now it's not clear from comment.
+                # See the ProductQuerySet.tagged
+                # for detail about `distinct` and `order_by` above
                 .distinct(*self.get_undirected_sorting_options())
                 .order_by(*self.get_undirected_sorting_options())
             )

catalog/context/__init__.py

@@ -0,0 +1 @@
+# @todo #183:120m Implement Page, PaginatedProducts, ProductBrands, ProductsImages context classes.

catalog/context/context.py

@@ -0,0 +1,55 @@
+import abc
+import collections
+import typing
+
+from django.db.models import QuerySet
+
+
+class Context(abc.ABC):
+
+    @abc.abstractmethod
+    def context(self) -> typing.Dict[str, typing.Any]:
+        ...
+
+
+class ModelContext(abc.ABC):
+
+    def __init__(self, qs: QuerySet):
+        self._qs = qs
+
+    def qs(self):
+        return self._qs
+
+    @abc.abstractmethod
+    def context(self) -> typing.Dict[str, typing.Any]:
+        ...
+
+
+Context.register(ModelContext)
+
+
+class Contexts(Context):
+
+    def __init__(self, *contexts: typing.List[Context]):
+        self.contexts = contexts
+
+    def context(self):
+        return collections.ChainMap(
+            *[ctx.context() for ctx in self.contexts]
+        )
+
+
+class Tags(ModelContext):
+
+    def context(self):
+        return {
+            'tags': self.qs(),
+        }
+
+
+class Products(ModelContext):
+
+    def context(self):
+        return {
+            'products': self.qs(),
+        }

catalog/context/products.py

@@ -0,0 +1,57 @@
+import typing
+
+from django.db.models import QuerySet
+
+from catalog.context.context import Products, Tags
+from catalog.models import AbstractCategory
+
+
+class ActiveProducts(Products):
+
+    def __init__(self, products: Products):
+        self._products = products
+
+    def qs(self):
+        return self._products.qs().active()
+
+
+class OrderedProducts(Products):
+
+    def __init__(self, products: Products, req_kwargs):
+        self._products = products
+        self._sorting_index = self._req_kwargs.get('sorting', 0)
+
+    def qs(self):
+        return self._products.qs().order_by(
+            SortingOption(index=self._sorting_index).directed_field,
+        )
+
+    def context(self):
+        return {
+            **super().context(),
+            'sorting_index': self._sorting_index,
+        }
+
+
+class ProductsByCategory(Products):
+
+    def __init__(self, products: Products, category: AbstractCategory):
+        self._products = products
+        self._category = category
+
+    def qs(self):
+        return self._products.qs().get_category_descendants(self._category)
+
+
+class ProductsByTags(Products):
+
+    def __init__(self, products: Products, tags_context: Tags):
+        self._products = products
+        self._tags = tags
+
+    def qs(self):
+        tags = self._tags.qs()
+        if tags.exists():
+            return self._products.qs().tagged(tags)
+        else:
+            return self._products.qs()

catalog/context/tags.py

@@ -0,0 +1,39 @@
+from catalog.context.context import Context, Tags, Products
+
+from django.db.models import QuerySet
+
+
+class GroupedTags(Context):
+
+    def __init__(self, tags: Tags):
+        self._tags = tags
+
+    def context(self):
+        return {
+            'group_tags_pairs': self._tags.qs().get_group_tags_pairs(),
+        }
+
+
+class ParsedTags(Tags):
+
+    def __init__(self, tags: Tags, req_kwargs):
+        self._tags = tags
+        self._raw_tags = req_kwargs.get('tags')
+
+    def qs(self):
+        tags = self._tags.qs()
+        if not self._raw_tags:
+            tags.none()
+        return tags.parsed(self._raw_tags)
+
+
+class Checked404Tags(Tags):
+
+    def __init__(self, tags: Tags):
+        self._tags = tags
+
+    def qs(self):
+        tags = self._tags.qs()
+        if not tags.exists():
+            raise http.Http404('No such tag.')
+        return tags

catalog/models.py

@@ -98,6 +98,7 @@ class ProductQuerySet(models.QuerySet):
     def get_offset(self, start, step):
         return self[start:start + step]
 
+    # @todo #183:30m Try to remove `ordering` arg from ProductQuerySet.get_by_category
     def get_by_category(self, category: models.Model, ordering: [str]=None) -> models.QuerySet:
         ordering = ordering or ['name']
         categories = category.get_descendants(True)
@@ -124,6 +125,17 @@ def filter_by_categories(self, categories: Iterable[AbstractCategory]):
     def active(self):
         return self.filter(page__is_active=True)
 
+    def tagged(self, tags):
+        # Distinct because a relation of tags and products is M2M.
+        # We do not specify the args for `distinct` to avoid dependencies
+        # between `order_by` and `distinct` methods.
+
+        # Postgres has `SELECT DISTINCT ON`, that depends on `ORDER BY`.
+        # See docs for details:
+        # https://www.postgresql.org/docs/10/static/sql-select.html#SQL-DISTINCT
+        # https://docs.djangoproject.com/en/2.1/ref/models/querysets/#django.db.models.query.QuerySet.distinct
+        return self.filter(tags__in=self._tags).distinct()
+
 
 class ProductManager(models.Manager.from_queryset(ProductQuerySet)):
     """Get all products of given category by Category's id or instance."""
@@ -142,6 +154,9 @@ def get_category_descendants(
     def active(self):
         return self.get_queryset().active()
 
+    def tagged(self, tags):
+        return self.get_queryset().tagged(tags)
+
 
 class AbstractProduct(models.Model, AdminTreeDisplayMixin):
     """
@@ -241,7 +256,7 @@ def get_group_tags_pairs(self) -> List[Tuple[TagGroup, List['Tag']]]:
             for group, tags_ in grouped_tags
         ]
 
-    def get_brands(self, products: List[AbstractProduct]) -> Dict[AbstractProduct, 'Tag']:
+    def get_brands(self, products: Iterable[AbstractProduct]) -> Dict[AbstractProduct, 'Tag']:
         brand_tags = (
             self.filter(group__name=settings.BRAND_TAG_GROUP_NAME)
             .prefetch_related('products')
@@ -324,6 +339,9 @@ def serialize_tags_to_title(self) -> str:
             group_delimiter=settings.TAG_GROUPS_TITLE_DELIMITER
         )
 
+    def parsed(self, raw: str):
+        return self.filter(slug__in=Tag.parse_url_tags(raw))
+
 
 class TagManager(models.Manager.from_queryset(TagQuerySet)):
 
@@ -343,6 +361,9 @@ def get_brands(self, products):
         """Get a batch of products' brands."""
         return self.get_queryset().get_brands(products)
 
+    def parsed(self, raw):
+        return self.get_queryset().parsed(raw)
+
 
 class Tag(models.Model):