Search: allow to search on different versions of subprojects

Author: stsewd

readthedocs/search/api.py

@@ -228,10 +228,17 @@ def _get_all_projects_data(self):
             superprojects__parent_id=main_project.id,
         )
         for project in subprojects:
-            version = self._get_subproject_versions_queryset(
-                main_version=main_version,
+            version = self._get_subproject_version(
+                version_slug=main_version.slug,
                 subproject=project,
-            ).first()
+            )
+            # Fallback to the default version of the subproject.
+            if not version and project.default_version:
+                version = self._get_subproject_version(
+                    version_slug=project.default_version,
+                    subproject=project,
+                )
+
             if version and self._has_permission(self.request.user, version):
                 url = project.get_docs_url(version_slug=version.slug)
                 projects_data[project.slug] = VersionData(
@@ -243,12 +250,13 @@ def _get_all_projects_data(self):
         setattr(self, cache_key, projects_data)
         return projects_data
 
-    def _get_subproject_versions_queryset(self, main_version, subproject):
-        """Get a queryset with the versions from the subproject that match `main_version`."""
+    def _get_subproject_version(self, version_slug, subproject):
+        """Get a version from the subproject."""
         return (
             Version.internal
             .public(user=self.request.user, project=subproject, include_hidden=False)
-            .filter(slug=main_version.slug)
+            .filter(slug=version_slug)
+            .first()
         )
 
     def _has_permission(self, user, version):
@@ -282,22 +290,20 @@ def get_queryset(self):
            calling ``search.execute().hits``. This is why an DSL search object
            is compatible with DRF's paginator.
         """
-        filters = {}
-        filters['project'] = list(self._get_all_projects_data().keys())
-        filters['version'] = self._get_version().slug
+        projects = {
+            project: version.slug
+            for project, version in self._get_all_projects_data().items()
+        }
 
-        # Check to avoid searching all projects in case these filters are empty.
-        if not filters['project']:
-            log.info('Unable to find a project to search')
-            return []
-        if not filters['version']:
+        # Check to avoid searching all projects in case it's empty.
+        if not projects:
             log.info('Unable to find a version to search')
             return []
 
         query = self.request.query_params['q']
         queryset = PageSearch(
             query=query,
-            filters=filters,
+            projects=projects,
             user=self.request.user,
             # We use a permission class to control authorization
             filter_by_user=False,

readthedocs/search/faceted_search.py

@@ -11,6 +11,7 @@
     MultiMatch,
     Nested,
     SimpleQueryString,
+    Term,
     Wildcard,
 )
 
@@ -35,12 +36,23 @@ class RTDFacetedSearch(FacetedSearch):
         'post_tags': ['</span>'],
     }
 
-    def __init__(self, query=None, filters=None, user=None, use_advanced_query=True, **kwargs):
+    def __init__(
+            self,
+            query=None,
+            filters=None,
+            projects=None,
+            user=None,
+            use_advanced_query=True,
+            **kwargs,
+    ):
         """
         Pass in a user in order to filter search results by privacy.
 
-        If `use_advanced_query` is `True`,
-        force to always use `SimpleQueryString` for the text query object.
+        :param projects: A dictionary of project slugs mapped to a `VersionData` object.
+        Results are filter with these values.
+
+        :param use_advanced_query: If `True` forces to always use
+        `SimpleQueryString` for the text query object.
 
         .. warning::
 
@@ -50,6 +62,7 @@ def __init__(self, query=None, filters=None, user=None, use_advanced_query=True,
         self.user = user
         self.filter_by_user = kwargs.pop('filter_by_user', True)
         self.use_advanced_query = use_advanced_query
+        self.projects = projects or {}
 
         # Hack a fix to our broken connection pooling
         # This creates a new connection on every request,
@@ -280,8 +293,22 @@ def query(self, search, query):
         )
 
         queries.extend([sections_nested_query, domains_nested_query])
+        bool_query = Bool(should=queries)
+
+        if self.projects:
+            versions_query = [
+                Bool(
+                    must=[
+                        Term(project={'value': project}),
+                        Term(version={'value': version}),
+                    ]
+                )
+                for project, version in self.projects.items()
+            ]
+            bool_query = Bool(must=[bool_query, Bool(should=versions_query)])
+
         final_query = FunctionScore(
-            query=Bool(should=queries),
+            query=bool_query,
             script_score=self._get_script_score(),
         )
         search = search.query(final_query)