Fragment references to AfO Reg. endpoint

ebl/afo_register/infrastructure/mongo_afo_register_repository.py

@@ -24,7 +24,7 @@ def create_search_query(query):
     if text_number != text_number_stripped:
         query["textNumber"] = text_number_stripped
     else:
-        query["textNumber"] = {"$regex": f"^{text_number}.*", "$options": "i"}
+        query["textNumber"] = {"$regex": f"^{text_number}", "$options": "i"}
     return query
 
 
@@ -99,9 +99,10 @@ def search_by_texts_and_numbers(
     def search_suggestions(
         self, text_query: str, *args, **kwargs
     ) -> Sequence[AfoRegisterRecordSuggestion]:
-        collated_query = list(make_query_params({"text": text_query}, "afo-register"))[
-            0
-        ]
+        collated_query_iter = iter(
+            make_query_params({"text": text_query}, "afo-register")
+        )
+        collated_query = next(collated_query_iter)
         pipeline = [
             {"$match": {"text": {"$regex": collated_query.value, "$options": "i"}}},
             {"$group": {"_id": "$text", "textNumbers": {"$addToSet": "$textNumber"}}},

ebl/common/query/query_result.py

@@ -40,6 +40,12 @@ class CorpusQueryItem:
     match_count: int
 
 
+@attr.s(auto_attribs=True, frozen=True)
+class AfORegisterToFragmentQueryItem:
+    traditional_reference: str
+    fragment_numbers: Sequence[str]
+
+
 @attr.s(auto_attribs=True, frozen=True)
 class CorpusQueryResult:
     items: Sequence[CorpusQueryItem]
@@ -48,3 +54,12 @@ class CorpusQueryResult:
     @staticmethod
     def create_empty() -> "CorpusQueryResult":
         return CorpusQueryResult([], 0)
+
+
+@attr.s(auto_attribs=True, frozen=True)
+class AfORegisterToFragmentQueryResult:
+    items: Sequence[AfORegisterToFragmentQueryItem]
+
+    @staticmethod
+    def create_empty() -> "AfORegisterToFragmentQueryResult":
+        return AfORegisterToFragmentQueryResult([])

ebl/common/query/query_schemas.py

@@ -4,6 +4,8 @@
     CorpusQueryResult,
     QueryItem,
     QueryResult,
+    AfORegisterToFragmentQueryResult,
+    AfORegisterToFragmentQueryItem,
 )
 from ebl.corpus.application.id_schemas import TextIdSchema
 from ebl.schemas import ValueEnumField
@@ -42,6 +44,20 @@ def make_query_item(self, data, **kwargs) -> CorpusQueryItem:
         return CorpusQueryItem(**data)
 
 
+class AfORegisterToFragmentQueryItemSchema(Schema):
+    traditional_reference = fields.String(
+        required=True, data_key="traditionalReference"
+    )
+    fragment_numbers = fields.List(
+        fields.String(), required=True, data_key="fragmentNumbers"
+    )
+
+    @post_load
+    def make_query_item(self, data, **kwargs) -> AfORegisterToFragmentQueryItem:
+        data["fragment_numbers"] = tuple(data["fragment_numbers"])
+        return AfORegisterToFragmentQueryItem(**data)
+
+
 class QueryResultSchema(Schema):
     match_count_total = fields.Integer(data_key="matchCountTotal", required=True)
     items = fields.Nested(QueryItemSchema, many=True, required=True)
@@ -57,3 +73,13 @@ class CorpusQueryResultSchema(QueryResultSchema):
     @post_load
     def make_query_result(self, data, **kwargs) -> CorpusQueryResult:
         return CorpusQueryResult(**data)
+
+
+class AfORegisterToFragmentQueryResultSchema(Schema):
+    items = fields.Nested(
+        AfORegisterToFragmentQueryItemSchema, many=True, required=True
+    )
+
+    @post_load
+    def make_query_result(self, data, **kwargs) -> AfORegisterToFragmentQueryResult:
+        return AfORegisterToFragmentQueryResult(**data)

ebl/fragmentarium/application/fragment_repository.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import List, Sequence, Optional
 from ebl.common.domain.scopes import Scope
-from ebl.common.query.query_result import QueryResult
+from ebl.common.query.query_result import QueryResult, AfORegisterToFragmentQueryResult
 
 from ebl.fragmentarium.application.line_to_vec import LineToVecEntry
 from ebl.fragmentarium.domain.fragment import Fragment
@@ -41,6 +41,14 @@
     ) -> Fragment:
         ...
 
+    @abstractmethod
+    def query_by_traditional_references(
+        self,
+        traditional_references: Sequence[str],
+        user_scopes: Sequence[Scope],
+    ) -> AfORegisterToFragmentQueryResult:
+        ...
+
     @abstractmethod
     def query_random_by_transliterated(
         self, user_scopes: Sequence[Scope]

ebl/fragmentarium/infrastructure/fragment_search_aggregations.py

@@ -89,13 +89,6 @@ def _filter_by_reference(self) -> Dict:
             }
         return {"references": {"$elemMatch": parameters}}
 
-    def _filter_by_traditional_references(self) -> Dict:
-        if traditional_references := self._query.get("traditionalReferences"):
-            return {
-                "traditionalReferences": {"$elemMatch": {"$eq": traditional_references}}
-            }
-        return {}
-
     def _prefilter(self) -> List[Dict]:
         constraints = {
             "$and": compact(
@@ -105,7 +98,6 @@ def _prefilter(self) -> List[Dict]:
                     self._filter_by_project(),
                     self._filter_by_script(),
                     self._filter_by_reference(),
-                    self._filter_by_traditional_references(),
                     match_user_scopes(self._scopes),
                 ]
             ),

ebl/fragmentarium/infrastructure/mongo_fragment_repository.py

@@ -6,8 +6,11 @@
 
 from ebl.bibliography.infrastructure.bibliography import join_reference_documents
 from ebl.common.domain.scopes import Scope
-from ebl.common.query.query_result import QueryResult
-from ebl.common.query.query_schemas import QueryResultSchema
+from ebl.common.query.query_result import QueryResult, AfORegisterToFragmentQueryResult
+from ebl.common.query.query_schemas import (
+    QueryResultSchema,
+    AfORegisterToFragmentQueryResultSchema,
+)
 from ebl.errors import NotFoundError
 from ebl.fragmentarium.application.fragment_info_schema import FragmentInfoSchema
 from ebl.fragmentarium.application.fragment_repository import FragmentRepository
@@ -30,6 +33,7 @@
     fragment_is,
     join_joins,
     join_findspots,
+    aggregate_by_traditional_references,
 )
 from ebl.fragmentarium.infrastructure.queries import match_user_scopes
 from ebl.mongo_collection import MongoCollection
@@ -38,6 +42,7 @@
 from ebl.transliteration.infrastructure.collections import FRAGMENTS_COLLECTION
 from ebl.transliteration.infrastructure.queries import query_number_is
 
+
 RETRIEVE_ALL_LIMIT = 1000
 
 
@@ -423,6 +428,21 @@ def query(self, query: dict, user_scopes: Sequence[Scope] = tuple()) -> QueryRes
 
         return QueryResultSchema().load(data) if data else QueryResult.create_empty()
 
+    def query_by_traditional_references(
+        self,
+        traditional_references: Sequence[str],
+        user_scopes: Sequence[Scope] = tuple(),
+    ) -> AfORegisterToFragmentQueryResult:
+        pipeline = aggregate_by_traditional_references(
+            traditional_references, user_scopes
+        )
+        data = self._fragments.aggregate(pipeline)
+        return (
+            AfORegisterToFragmentQueryResultSchema().load({"items": data})
+            if data
+            else AfORegisterToFragmentQueryResult.create_empty()
+        )
+
     def list_all_fragments(
         self, user_scopes: Sequence[Scope] = tuple()
     ) -> Sequence[str]:

ebl/fragmentarium/infrastructure/queries.py

@@ -341,3 +341,46 @@ def join_findspots() -> List[dict]:
         {"$addFields": {"archaeology.findspot": {"$first": "$findspots"}}},
         {"$project": {"findspots": False}},
     ]
+
+
+def aggregate_by_traditional_references(
+    traditional_references: Sequence[str], user_scopes: Sequence[Scope] = tuple()
+) -> List[dict]:
+    return [
+        {
+            "$match": {
+                "traditionalReferences": {"$in": traditional_references},
+                **match_user_scopes(user_scopes),
+            }
+        },
+        {
+            "$project": {
+                "_id": 1,
+                "traditionalReference": {
+                    "$arrayElemAt": [
+                        {
+                            "$filter": {
+                                "input": "$traditionalReferences",
+                                "as": "ref",
+                                "cond": {"$in": ["$$ref", traditional_references]},
+                            }
+                        },
+                        0,
+                    ]
+                },
+            }
+        },
+        {
+            "$group": {
+                "_id": "$traditionalReference",
+                "fragmentNumbers": {"$addToSet": "$_id"},
+            }
+        },
+        {
+            "$project": {
+                "traditionalReference": "$_id",
+                "fragmentNumbers": 1,
+                "_id": 0,
+            }
+        },
+    ]

ebl/fragmentarium/web/bootstrap.py

@@ -35,6 +35,9 @@
 from ebl.fragmentarium.web.introductions import IntroductionResource
 from ebl.fragmentarium.web.archaeology import ArchaeologyResource
 from ebl.fragmentarium.web.notes import NotesResource
+from ebl.fragmentarium.web.fragments_afo_register import (
+    AfoRegisterFragmentsQueryResource,
+)
 from ebl.corpus.web.chapters import ChaptersByManuscriptResource
 from ebl.corpus.application.corpus import Corpus
 
@@ -90,6 +93,9 @@ def create_fragmentarium_routes(api: falcon.App, context: Context):
     fragment_query = FragmentsQueryResource(
         context.fragment_repository, context.get_transliteration_query_factory()
     )
+    afo_register_fragments_query = AfoRegisterFragmentsQueryResource(
+        context.fragment_repository, finder
+    )
     genres = GenresResource()
     periods = PeriodsResource()
     lemmatization = LemmatizationResource(updater)
@@ -137,6 +143,7 @@ def create_fragmentarium_routes(api: falcon.App, context: Context):
         ("/fragments/{number}/pager/{folio_name}/{folio_number}", folio_pager),
         ("/folios/{name}/{number}", folios),
         ("/fragments/query", fragment_query),
+        ("/fragments/query-by-traditional-references", afo_register_fragments_query),
         ("/fragments/all", all_fragments),
         ("/findspots", findspots),
     ]

ebl/fragmentarium/web/fragments_afo_register.py

@@ -0,0 +1,26 @@
+from falcon import Request, Response
+
+from ebl.errors import DataError
+from ebl.fragmentarium.application.fragment_repository import FragmentRepository
+from ebl.fragmentarium.application.fragment_finder import FragmentFinder
+
+from marshmallow import ValidationError
+from ebl.common.query.query_schemas import AfORegisterToFragmentQueryResultSchema
+
+
+class AfoRegisterFragmentsQueryResource:
+    def __init__(self, fragment_repository: FragmentRepository, finder: FragmentFinder):
+        self._repository = fragment_repository
+        self._finder = finder
+
+    def on_post(self, req: Request, resp: Response) -> None:
+        try:
+            result = self._repository.query_by_traditional_references(
+                req.media["traditionalReferences"],
+                req.context.user.get_scopes(prefix="read:", suffix="-fragments"),
+            )
+            resp.media = AfORegisterToFragmentQueryResultSchema().dump(result)
+        except ValidationError as error:
+            raise DataError(
+                f"Invalid datesInText data: '{req.media['traditionalReferences']}'"
+            ) from error

ebl/tests/fragmentarium/test_fragment_afo_register_route.py

@@ -0,0 +1,30 @@
+import falcon
+import json
+from ebl.tests.factories.fragment import (
+    FragmentFactory,
+)
+from ebl.tests.factories.afo_register import AfoRegisterRecordFactory
+
+
+def test_query_fragmentarium_afo_register(fragment_repository, client):
+    record = AfoRegisterRecordFactory.build()
+    record_id = f"{record.text} {record.text_number}"
+    fragment = FragmentFactory.build(traditional_references=[record_id])
+    fragment_repository.create_many([fragment, FragmentFactory.build()])
+
+    post_result = client.simulate_post(
+        "/fragments/query-by-traditional-references",
+        body=json.dumps({"traditionalReferences": [record_id]}),
+    )
+
+    expected_json = {
+        "items": [
+            {
+                "traditionalReference": record_id,
+                "fragmentNumbers": [str(fragment.number)],
+            }
+        ]
+    }
+
+    assert post_result.status == falcon.HTTP_OK
+    assert post_result.json == expected_json

ebl/tests/fragmentarium/test_fragment_repository_afo_register.py

@@ -0,0 +1,25 @@
+from ebl.common.query.query_schemas import (
+    AfORegisterToFragmentQueryResultSchema,
+)
+from ebl.tests.factories.fragment import (
+    FragmentFactory,
+)
+from ebl.tests.factories.afo_register import AfoRegisterRecordFactory
+
+
+def test_query_fragmentarium_afo_register(fragment_repository):
+    record = AfoRegisterRecordFactory.build()
+    record_id = f"{record.text} {record.text_number}"
+    fragment = FragmentFactory.build(traditional_references=[record_id])
+    fragment_repository.create_many([fragment, FragmentFactory.build()])
+    result = fragment_repository.query_by_traditional_references([record_id])
+    assert result == AfORegisterToFragmentQueryResultSchema().load(
+        {
+            "items": [
+                {
+                    "traditionalReference": record_id,
+                    "fragmentNumbers": [str(fragment.number)],
+                }
+            ]
+        }
+    )