Added tags/filters method

apps/tag/serializers.py

@@ -98,11 +98,13 @@ class TagCategoryBaseSerializer(serializers.ModelSerializer):
         return TagBaseSerializer(instance=tags, many=True, read_only=True).data
 
 
-class TestBaseSerializer(serializers.ModelSerializer):
+class FiltersTagCategoryBaseSerializer(serializers.ModelSerializer):
     """Serializer for model TagCategory."""
 
     label_translated = TranslatedField()
-    tags = SerializerMethodField()
+    filters = SerializerMethodField()
+    param_name = SerializerMethodField()
+    type = SerializerMethodField()
 
     class Meta:
         """Meta class."""
@@ -110,17 +112,44 @@ class TestBaseSerializer(serializers.ModelSerializer):
         model = models.TagCategory
         fields = (
             'id',
-            'transliterated_name',
+            'label_translated',
-            'name',
+            'index_name',
-            'tags',
+            'param_name',
+            'type',
+            'filters',
         )
 
+    def get_type(self, obj):
+        return obj in ['open_now', ]
+
+    def get_param_name(self, obj):
+        if obj == 'service':
+            return 'tags_id__in'
+
+        elif obj == 'pop':
+            return 'tags_id__in'
+
+        elif obj == 'open_now':
+            return 'open_now'
+
+        elif obj == 'wine_region':
+            return 'wine_region_id__in'
+
+        return '%s__in' % obj.index_name
+
+    def get_fields(self, *args, **kwargs):
+        fields = super(FiltersTagCategoryBaseSerializer, self).get_fields()
+
+        if self.get_type(self):
+            fields.pop('filters', None)
+        else:
+            fields.pop('type', None)
+
+        return fields
+
     def get_filters(self, obj):
         query_params = dict(self.context['request'].query_params)
 
-        if len(query_params) > 1:
-            return []
-
         params = {}
         if 'establishment_type' in query_params:
             params = {

apps/tag/urls/web.py

@@ -7,7 +7,7 @@ app_name = 'tag'
 
 router = SimpleRouter()
 router.register(r'categories', views.TagCategoryViewSet)
-router.register(r'categories_test', views.TestTagCategoryViewSet)
+router.register(r'filters', views.FiltersTagCategoryViewSet)
 router.register(r'chosen_tags', views.ChosenTagsView)
 
 urlpatterns = [

apps/tag/views.py

@@ -11,15 +11,10 @@ from rest_framework import viewsets
 from rest_framework.decorators import action
 from rest_framework.response import Response
 
-from search_indexes import utils
+from location.models import WineRegion
-from search_indexes.documents import EstablishmentDocument
-from search_indexes.filters import CustomFacetedSearchFilterBackend
-from search_indexes.filters import CustomSearchFilterBackend
-from search_indexes.serializers import EstablishmentDocumentSerializer
 from tag import filters
 from tag import models
 from tag import serializers
-from utils.pagination import ESDocumentPagination
 
 
 class ChosenTagsView(generics.ListAPIView, viewsets.GenericViewSet):
@@ -69,116 +64,94 @@ class TagCategoryViewSet(mixins.ListModelMixin, viewsets.GenericViewSet):
 
 
 # User`s views & viewsets
-class TestTagCategoryViewSet(mixins.ListModelMixin, viewsets.GenericViewSet):
+class FiltersTagCategoryViewSet(mixins.ListModelMixin, viewsets.GenericViewSet):
     """ViewSet for TagCategory model."""
 
-    filterset_classes = [
+    filterset_class = filters.TagCategoryFilterSet
-        filters.TagCategoryFilterSet,
+    pagination_class = None
-        FilteringFilterBackend,
-        CustomSearchFilterBackend,
-        CustomFacetedSearchFilterBackend,
-    ]
-
-    document = EstablishmentDocument
-    pagination_class = ESDocumentPagination
     permission_classes = (permissions.AllowAny,)
     queryset = models.TagCategory.objects.with_tags().with_base_related(). \
         distinct()
-    serializer_class = serializers.TestBaseSerializer
+    serializer_class = serializers.FiltersTagCategoryBaseSerializer
 
-    faceted_search_fields = {
+    def list(self, request, *args, **kwargs):
-        'works_at_weekday': {
+        queryset = self.filter_queryset(self.get_queryset())
-            'field': 'works_at_weekday',
+        serializer = self.get_serializer(queryset, many=True)
-            'facet': TermsFacet,
-            'enabled': True,
-        },
-        'toque_number': {
-            'field': 'toque_number',
-            'enabled': True,
-            'facet': TermsFacet,
-        },
-        'works_noon': {
-            'field': 'works_noon',
-            'facet': TermsFacet,
-            'enabled': True,
-        },
-        'works_evening': {
-            'field': 'works_evening',
-            'facet': TermsFacet,
-            'enabled': True,
-        },
-        'works_now': {
-            'field': 'works_now',
-            'facet': TermsFacet,
-            'enabled': True,
-        },
-        'tag': {
-            'field': 'tags.id',
-            'facet': TermsFacet,
-            'enabled': True,
-            'options': {
-                'size': utils.FACET_MAX_RESPONSE,
-            },
-        }
-    }
 
-    search_fields = {
+        result_list = serializer.data
-        'name': {
+        query_params = request.query_params
-            'fuzziness': 'auto:2,5',
-            'boost': 4
-        },
-        'transliterated_name': {
-            'fuzziness': 'auto:2,5',
-            'boost': 3
-        },
-        'description': {'fuzziness': 'auto:2,5'},
-    }
-    translated_search_fields = (
-        'description',
-    )
-    filter_fields = {
-        'slug': 'slug',
-        'tag': {
-            'field': 'tags.id',
-            'lookups': [constants.LOOKUP_QUERY_IN]
-        },
-        'toque_number': {
-            'field': 'toque_number',
-            'lookups': [
-                constants.LOOKUP_FILTER_RANGE,
-                constants.LOOKUP_QUERY_GT,
-                constants.LOOKUP_QUERY_GTE,
-                constants.LOOKUP_QUERY_LT,
-                constants.LOOKUP_QUERY_LTE,
-                constants.LOOKUP_QUERY_IN,
-            ]
-        },
 
-        'works_noon': {
+        if 'toque_number__in' in query_params:
-            'field': 'works_noon',
+            toques = {
-            'lookups': [
+                "index_name": "toque_number",
-                constants.LOOKUP_QUERY_IN,
+                "label_translated": "Toques",
-            ],
+                "param_name": "toque_number__in",
-        },
+                "filters": [{
-        'works_at_weekday': {
+                    "id": toque_id,
-            'field': 'works_at_weekday',
+                    "index_name": "toque_%d" % toque_id,
-            'lookups': [
+                    "label_translated": "Toque %d" % toque_id
-                constants.LOOKUP_QUERY_IN,
+                } for toque_id in range(6)]
-            ],
+            }
-        },
+            result_list.append(toques)
-        'works_evening': {
+
-            'field': 'works_evening',
+        if 'wine_region_id__in' in query_params:
-            'lookups': [
+            try:
-                constants.LOOKUP_QUERY_IN,
+                wine_region_id = int(query_params['wine_region_id__in'])
-            ],
+
-        },
+                wine_regions = {
-        'works_now': {
+                    "index_name": "wine_region",
-            'field': 'works_now',
+                    "label_translated": "Wine region",
-            'lookups': [
+                    "param_name": "wine_region_id__in",
-                constants.LOOKUP_FILTER_TERM,
+                    "filters": [{
-            ]
+                        "id": obj.id,
-        },
+                        "index_name": obj.name.lower().replace(' ', '_'),
-    }
+                        "label_translated": obj.name
+                    } for obj in WineRegion.objects.filter(id=wine_region_id)]
+                }
+
+                result_list.append(wine_regions)
+
+            except ValueError:
+                pass
+
+        if 'works_noon__in' in query_params:
+            week_days = ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday")
+            works_noon = {
+                "index_name": "works_noon",
+                "label_translated": "Open noon",
+                "param_name": "works_noon__in",
+                "filters": [{
+                    "id": weekday,
+                    "index_name": week_days[weekday].lower(),
+                    "label_translated": week_days[weekday]
+                } for weekday in range(7)]
+            }
+            result_list.append(works_noon)
+
+        if 'works_evening__in' in query_params:
+            week_days = ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday")
+            works_evening = {
+                "index_name": "works_evening",
+                "label_translated": "Open noon",
+                "param_name": "works_evening__in",
+                "filters": [{
+                    "id": weekday,
+                    "index_name": week_days[weekday].lower(),
+                    "label_translated": week_days[weekday]
+                } for weekday in range(7)]
+            }
+            result_list.append(works_evening)
+
+        if 'works_now' in query_params:
+            works_now = {
+                "index_name": "open_now",
+                "label_translated": "Open now",
+                "param_name": "open_now",
+                "type": True
+            }
+            result_list.append(works_now)
+
+        return Response(result_list)
 
 
 # BackOffice user`s views & viewsets
@@ -271,4 +244,4 @@ class TagCategoryBackOfficeViewSet(mixins.CreateModelMixin,
         if obj_type == self.bind_object_serializer_class.ESTABLISHMENT_TYPE:
             tag_category.establishment_types.remove(related_object)
         elif obj_type == self.bind_object_serializer_class.NEWS_TYPE:
-            tag_category.news_types.remove(related_object)
+            tag_category.news_types.remove(related_object)