Person suggest

.vscode/launch.json

@@ -8,7 +8,8 @@
             "program": "${workspaceFolder}/src/manage.py",
             "args": [
                 "runserver",
-                "[::]:8000"
+                "[::]:8000",
+                "--ipv6"
             ],
             "env": {
                 "USE_DEBUG_TOOLBAR": "True"

src/search/documents/person.py

@@ -17,7 +17,6 @@
     full_name = es_fields.TextField(attr="full_name", analyzer=content_analyzer)
     person_types = es_fields.KeywordField(attr="person_types_indexing")
     headline = es_fields.ObjectField(
-        attr="headline",
         properties={
             "title": es_fields.TextField(),
         },
@@ -29,6 +28,11 @@
             "name": es_fields.TextField(),
         },
     )
+    suggestion_phrases = es_fields.Completion()
+    user_id = es_fields.IntegerField(attr="user_id")
+    reputation_hubs = es_fields.KeywordField()
+    education = es_fields.KeywordField()
+    created_date = es_fields.DateField(attr="created_date")
 
     class Index:
         name = "person"
@@ -43,3 +47,62 @@
 
     def should_remove_from_index(self, obj):
         return False
+
+    def prepare_headline(self, instance):
+        return instance.build_headline()
+
+    def prepare_reputation_hubs(self, instance):
+        reputation_hubs = []
+        for rep in instance.reputation_list:
+            reputation_hubs.append(rep["hub"]["name"])
+
+        return reputation_hubs
+
+    def prepare_education(self, instance):
+        education = []
+        for edu in instance.education:
+            education.append(edu["name"])
+
+        return education
+
+    def prepare_suggestion_phrases(self, instance):
+        suggestions = []
+
+        if instance.full_name:
+            if instance.user:
+                suggestions.append({"input": instance.full_name, "weight": 15})
+            else:
+                suggestions.append({"input": instance.full_name, "weight": 10})
+
+        if instance.first_name:
+            suggestions.append({"input": instance.first_name, "weight": 5})
+        if instance.last_name:
+            suggestions.append({"input": instance.last_name, "weight": 5})
+
+        # Add institution names
+        for author_institution in instance.institutions.all():
+            if author_institution.institution.display_name:
+                suggestions.append(
+                    {"input": author_institution.institution.display_name, "weight": 3}
+                )
+
+                # Add full name + institution to account for people typing name + institution
+                suggestions.append(
+                    {
+                        "input": instance.first_name
+                        + " "
+                        + author_institution.institution.display_name,
+                        "weight": 3,
+                    }
+                )
+
+        return suggestions
+
+    def prepare(self, instance):
+        data = super().prepare(instance)
+        try:
+            data["suggestion_phrases"] = self.prepare_suggestion_phrases(instance)
+        except Exception as error:
+            print(f"Error preparing suggestions for {instance.id}: {error}")
+            data["suggestion_phrases"] = []
+        return data

src/search/urls.py

@@ -15,6 +15,7 @@
 )
 from search.views.journal import JournalDocumentView
 from search.views.journal_suggester import JournalSuggesterDocumentView
+from search.views.person_suggester import PersonSuggesterDocumentView
 
 router = DefaultRouter()
 person = router.register(r"person", PersonDocumentView, basename="person_document")
@@ -33,6 +34,9 @@
 journal_suggester = router.register(
     r"journals", JournalSuggesterDocumentView, basename="journal_suggester_document"
 )
+people_suggester = router.register(
+    r"people", PersonSuggesterDocumentView, basename="people_suggester"
+)
 
 urlpatterns = [
     re_path(r"^", include(router.urls)),

src/search/views/__init__.py

@@ -6,6 +6,7 @@
 from .hub_suggester import HubSuggesterDocumentView
 from .paper import PaperDocumentView
 from .person import PersonDocumentView
+from .person_suggester import PersonSuggesterDocumentView
 from .post import PostDocumentView
 from .thread import ThreadDocumentView
 from .user_suggester import UserSuggesterDocumentView

src/search/views/person_suggester.py

@@ -0,0 +1,49 @@
+from django_elasticsearch_dsl_drf.filter_backends import (
+    OrderingFilterBackend,
+    SuggesterFilterBackend,
+)
+from django_elasticsearch_dsl_drf.pagination import LimitOffsetPagination
+from django_elasticsearch_dsl_drf.viewsets import DocumentViewSet
+
+from search.backends.multi_match_filter import MultiMatchSearchFilterBackend
+from search.documents.person import PersonDocument
+from search.serializers.person import PersonDocumentSerializer
+from utils.permissions import ReadOnly
+
+
+class PersonSuggesterDocumentView(DocumentViewSet):
+    document = PersonDocument
+    permission_classes = [ReadOnly]
+    serializer_class = PersonDocumentSerializer
+    pagination_class = LimitOffsetPagination
+    lookup_field = "id"
+    filter_backends = [
+        MultiMatchSearchFilterBackend,
+        SuggesterFilterBackend,
+        OrderingFilterBackend,
+    ]
+
+    ordering = ("-author_score",)
+    ordering_fields = {
+        "id": "id",
+        "full_name": "full_name",
+        "author_score": "author_score",
+    }
+
+    filter_fields = {
+        "full_name": {"field": "full_name", "lookups": ["match"]},
+    }
+
+    multi_match_search_fields = {
+        "full_name": {"field": "full_name", "boost": 1},
+    }
+
+    suggester_fields = {
+        "suggestion_phrases": {
+            "field": "suggestion_phrases",
+            "suggesters": ["completion"],
+            "options": {
+                "size": 25,
+            },
+        },
+    }

src/user/related_models/author_model.py

@@ -117,6 +117,39 @@
             f"{university_city}"
         )
 
+    def build_headline(self):
+        from collections import Counter
+
+        if self.headline:
+            return self.headline
+
+        try:
+            all_topics = []
+            authored_papers = self.authored_papers.all()
+
+            for p in authored_papers:
+                unified_document = p.unified_document
+                all_topics += list(unified_document.topics.all())
+
+            topic_counts = Counter(all_topics)
+
+            # Sort topics by frequency
+            sorted_topics = sorted(
+                topic_counts.items(), key=lambda x: x[1], reverse=True
+            )
+
+            # Extract topics from sorted list
+            sorted_topics = [topic for topic, _ in sorted_topics]
+
+            if not sorted_topics:
+                return None
+
+            return {
+                "title": "Author with expertise in " + sorted_topics[0].display_name
+            }
+        except Exception:
+            return None
+
     @property
     def full_name(self):
         return self.first_name + " " + self.last_name

src/user/serializers.py

@@ -1092,37 +1092,7 @@ def get_achievements(self, author):
         return author.achievements
 
     def get_headline(self, author):
-        from collections import Counter
-
-        if author.headline:
-            return author.headline
-
-        try:
-            all_topics = []
-            authored_papers = author.authored_papers.all()
-
-            for p in authored_papers:
-                unified_document = p.unified_document
-                all_topics += list(unified_document.topics.all())
-
-            topic_counts = Counter(all_topics)
-
-            # Sort topics by frequency
-            sorted_topics = sorted(
-                topic_counts.items(), key=lambda x: x[1], reverse=True
-            )
-
-            # Extract topics from sorted list
-            sorted_topics = [topic for topic, _ in sorted_topics]
-
-            if not sorted_topics:
-                return None
-
-            return {
-                "title": "Author with expertise in " + sorted_topics[0].display_name
-            }
-        except Exception:
-            return None
+        return author.build_headline()
 
     def get_user(self, author):
         user = author.user