From 471fe2d1d8b6867da6567126cd1cc6f242764887 Mon Sep 17 00:00:00 2001 From: duker33 Date: Mon, 17 Sep 2018 16:55:40 +0700 Subject: [PATCH] se#577 Move context module to refarm.catalog app (#180) --- catalog/context.py | 449 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 449 insertions(+) create mode 100644 catalog/context.py diff --git a/catalog/context.py b/catalog/context.py new file mode 100644 index 0000000..40794c6 --- /dev/null +++ b/catalog/context.py @@ -0,0 +1,449 @@ +""" +Contains view context classes. + +Context is our own concept. +It's part of the View abstract layer in MTV paradigm. +Data flow looks like this: +Urls -> Context -> View. +So, by concept, View receives context directly +without accessing url args. +It stands between urls and view functions. + +Every context class is used via objects composition. +Code example to create tagged category: + +>>> from django.http import HttpRequest +>>> url_kwargs = {'slug': 'my-page'} +>>> Category(url_kwargs, request=HttpRequest()) | TaggedCategory() +""" + +import typing +from abc import ABC, abstractmethod +from collections import defaultdict +from functools import lru_cache, partial + +from django import http +from django.conf import settings +from django.db.models import QuerySet +from django.core.paginator import Paginator, InvalidPage +from django_user_agents.utils import get_user_agent + +from catalog.models import ProductQuerySet, Tag, TagQuerySet +from images.models import Image +from pages.models import ModelPage + + +class SortingOption: + def __init__(self, index=0): + options = settings.CATEGORY_SORTING_OPTIONS[index] + self.label = options['label'] + self.field = options['field'] + self.direction = options['direction'] + + @property + def directed_field(self): + return self.direction + self.field + + +class PaginatorLinks: + + def __init__(self, number, path, paginated: Paginator): + self.paginated = paginated + self.number = number + self.path = path + + self.index = number - 1 + self.neighbor_bounds = settings.PAGINATION_NEIGHBORS // 2 + self.neighbor_range = list(self.paginated.page_range) + + def page(self): + try: + return self.paginated.page(self.number) + except InvalidPage: + raise http.Http404('Page does not exist') + + def showed_number(self): + return self.index * self.paginated.per_page + self.page().object_list.count() + + def _url(self, number): + self.paginated.validate_number(number) + return self.path if number == 1 else f'{self.path}?page={number}' + + def prev_numbers(self): + return self.neighbor_range[:self.index][-self.neighbor_bounds:] + + def next_numbers(self): + return self.neighbor_range[self.index + 1:][:self.neighbor_bounds] + + def number_url_map(self): + numbers = self.prev_numbers() + self.next_numbers() + return {number: self._url(number) for number in numbers} + + +# @todo #550:30m Split to ProductImagesContext and ProductBrandContext +@lru_cache(maxsize=64) +def prepare_tile_products( + products: ProductQuerySet, product_pages: QuerySet, tags: TagQuerySet=None +): + # @todo #550:60m Move prepare_tile_products func to context + # Now it's separated function with huge of inconsistent queryset deps. + assert isinstance(products, ProductQuerySet) + + images = Image.objects.get_main_images_by_pages( + product_pages.filter(shopelectro_product__in=products) + ) + + brands = ( + tags + .filter_by_products(products) + .get_brands(products) + ) if tags else defaultdict(lambda: None) + + return [ + (product, images.get(product.page), brands.get(product)) + for product in products + ] + + +class ObjectsComposition: + + super: 'ObjectsComposition' = None + + def __or__(self, other: 'ObjectsComposition'): + other.super = self + return other + + +# @todo #550:120m Move context realization to pure to objects composition. +# Discussed some thoughts with Artemiy via call. +# Artemiy will do it. +# For example SortedCategory should +# consist of separated SortedList and Category classes/objects. +class AbstractContext(ObjectsComposition, ABC): + + super: 'AbstractContext' = None + + def __init__( # Ignore PyDocStyleBear + self, + url_kwargs: typing.Dict[str, str]=None, + request: http.HttpRequest=None + ): + """ + :param url_kwargs: Came from `urls` module. + :param request: Came from `urls` module + """ + + self.url_kwargs_ = url_kwargs or {} + self.request_ = request + + @property + def url_kwargs(self) -> typing.Dict[str, str]: + return self.url_kwargs_ or self.super.url_kwargs + + @property + def request(self) -> http.HttpRequest: + return self.request_ or self.super.request + + @abstractmethod + def get_context_data(self) -> typing.Dict[str, typing.Any]: + ... + + +class AbstractPageContext(AbstractContext, ABC): + + super: 'AbstractPageContext' = None + + def __init__( # Ignore PyDocStyleBear + self, + url_kwargs: typing.Dict[str, str]=None, + request: http.HttpRequest=None + ): + """ + :param url_kwargs: Came from `urls` module. + :param request: Came from `urls` module + """ + + if url_kwargs: + assert 'slug' in url_kwargs + super().__init__(url_kwargs, request) + + @property + def slug(self) -> str: + return self.url_kwargs['slug'] + + @property + @lru_cache(maxsize=1) + def page(self): + return ModelPage.objects.get(slug=self.slug) + + +class AbstractProductsListContext(AbstractPageContext, ABC): + + super: 'AbstractProductsListContext' = None + + def __init__( # Ignore PyDocStyleBear + self, + url_kwargs: typing.Dict[str, str]=None, + request: http.HttpRequest=None, + products: ProductQuerySet=None, + product_pages: QuerySet=None, + ): + """ + :param url_kwargs: Came from `urls` module. + :param request: Came from `urls` module. + :param products: Every project provides products from DB. + """ + super().__init__(url_kwargs, request) + self.products_ = products + self.product_pages_ = product_pages + + @property + def product_pages(self) -> QuerySet: + return self.product_pages_ or self.super.product_pages + + @property + def products(self) -> ProductQuerySet: + if self.super: + return self.super.products + elif self.products_: + return self.products_ + else: + raise NotImplementedError('Set products queryset') + + +class Category(AbstractProductsListContext): + @property + def products(self) -> ProductQuerySet: + return super().products.active().get_category_descendants( + self.page.model + ) + + def get_context_data(self): + """Add sorting options and view_types in context.""" + # @todo #550:15m Take `view_type` value from dataclass. + # Depends on updating to python3.7 + view_type = self.request.session.get('view_type', 'tile') + + return { + 'products_data': prepare_tile_products(self.products, self.product_pages), + # can be `tile` or `list`. Defines products list layout. + 'view_type': view_type, + } + + +class TaggedCategory(AbstractProductsListContext): + + def __init__( # Ignore PyDocStyleBear + self, + url_kwargs: typing.Dict[str, str]=None, + request: http.HttpRequest=None, + products: ProductQuerySet=None, + tags: TagQuerySet=None + ): + """ + :param url_kwargs: Came from `urls` module. + :param request: Came from `urls` module. + :param products: Every project provides products from DB. + :param tags: Every project provides tags from DB. + """ + super().__init__(url_kwargs, request, products) + # it's not good. Arg should not be default. + # That's how we'll prevent assertion. + # But we'll throw away inheritance in se#567. + assert tags, 'tags is required arg' + self.tags_ = tags + + def get_sorting_index(self): + return int(self.url_kwargs.get('sorting', 0)) + + # @todo #550:15m Move `TaggedCategory.get_tags` to property. + # As in `products` property case. + def get_tags(self) -> typing.Optional[TagQuerySet]: + request_tags = self.url_kwargs.get('tags') + if not request_tags: + return None + + slugs = Tag.parse_url_tags(request_tags) + tags = self.tags_.filter(slug__in=slugs) + if not tags: + raise http.Http404('No such tag.') + return tags + + @property + def products(self): + products = self.super.products + sorting_option = SortingOption(index=self.get_sorting_index()) + tags = self.get_tags() + if tags: + 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. + .distinct(sorting_option.field) + .order_by(sorting_option.field) + ) + return products + + def get_context_data(self): + context = self.super.get_context_data() + tags = self.get_tags() + group_tags_pairs = ( + self.tags_ + .filter_by_products(self.products) + .get_group_tags_pairs() + ) + return { + **context, + 'tags': tags, + 'group_tags_pairs': group_tags_pairs, + 'products_data': prepare_tile_products( + self.products, + self.product_pages, + # requires all tags, not only selected + self.tags_ + ), + # Category's canonical link is `category.page.get_absolute_url`. + # So, this link always contains no tags. + # That's why we skip canonical link on tagged category page. + 'skip_canonical': bool(tags), + } + + +class DBTemplate(AbstractPageContext): + """Processes some page data fields as templates with their own context.""" + + @property + @lru_cache(maxsize=1) + def page(self): + page = self.super.page + context = self.get_super_context_data_cached() + + def template_context(page, tag_titles, tags): + return { + 'page': page, + 'tag_titles': tag_titles, + 'tags': tags, + } + + tags = context['tags'] + if tags: + tag_titles = tags.as_title() + page.get_template_render_context = partial( + template_context, page, tag_titles, tags + ) + + return page + + @lru_cache(maxsize=1) + def get_super_context_data_cached(self): + return self.super.get_context_data() + + @lru_cache(maxsize=1) + def get_context_data(self): + return { + **self.get_super_context_data_cached(), + 'page': self.page, + } + + +class SortingCategory(AbstractProductsListContext): + + def get_sorting_index(self): + return int(self.url_kwargs.get('sorting', 0)) + + @property + def products(self) -> ProductQuerySet: + sorting_index = int(self.url_kwargs.get('sorting', 0)) + sorting_option = SortingOption(index=sorting_index) + return self.super.products.order_by(sorting_option.directed_field) + + def get_context_data(self): + context = self.super.get_context_data() + return { + **context, + 'products_data': prepare_tile_products( + self.products, self.product_pages + ), + 'sort': self.get_sorting_index(), + } + + +class PaginationCategory(AbstractProductsListContext): + + def get_products_count(self): + """Calculate max products list size from request. List size depends on device type.""" + mobile_view = get_user_agent(self.request).is_mobile + return settings.PRODUCTS_ON_PAGE_MOB if mobile_view else settings.PRODUCTS_ON_PAGE_PC + + def get_paginated_page_or_404(self, per_page, page_number) -> Paginator: + try: + return Paginator(self.all_products, per_page).page(page_number) + except InvalidPage: + raise http.Http404('Page does not exist') + + @property + def products_on_page(self): + return int(self.request.GET.get( + 'step', self.get_products_count(), + )) + + @property + def page_number(self): + return int(self.request.GET.get('page', 1)) + + @property + def all_products(self) -> ProductQuerySet: + return self.super.products + + @property + def products(self) -> ProductQuerySet: + """Only products for current page.""" + paginated_page = self.get_paginated_page_or_404( + self.products_on_page, self.page_number + ) + # it's queryset, but it's sliced + products: ProductQuerySet = paginated_page.object_list + return products + + @property + def products_count(self): + return (self.page_number - 1) * self.products_on_page + self.products.count() + + def check_pagination_args(self): + if ( + self.page_number < 1 or + self.products_on_page not in settings.CATEGORY_STEP_MULTIPLIERS + ): + raise http.Http404('Page does not exist.') # Ignore CPDBear + + def get_context_data(self): + context = self.super.get_context_data() + self.check_pagination_args() + + if not self.products: + raise http.Http404('Page without products does not exist.') + + paginated = PaginatorLinks( + self.page_number, + self.request.path, + Paginator(self.all_products, self.products_on_page) + ) + paginated_page = paginated.page() + + total_products = self.all_products.count() + + return { + **context, + 'products_data': prepare_tile_products( + self.products, self.product_pages + ), + 'total_products': total_products, + 'products_count': self.products_count, + 'paginated': paginated, + 'paginated_page': paginated_page, + 'sorting_options': settings.CATEGORY_SORTING_OPTIONS.values(), + 'limits': settings.CATEGORY_STEP_MULTIPLIERS, + }