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,8 @@ 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,18 @@ 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 +71,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,10 @@
 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.common.query.query_schemas import (
+    AfORegisterToFragmentQueryResultSchema,
+)
 
 from ebl.fragmentarium.application.line_to_vec import LineToVecEntry
 from ebl.fragmentarium.domain.fragment import Fragment
@@ -41,6 +44,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/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
@@ -38,6 +41,7 @@
 from ebl.transliteration.infrastructure.collections import FRAGMENTS_COLLECTION
 from ebl.transliteration.infrastructure.queries import query_number_is
 
+
 RETRIEVE_ALL_LIMIT = 1000
 
 
@@ -423,6 +427,50 @@ 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 = [
+            {
+                "$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}},
+        ]
+        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/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,27 @@
+import falcon
+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_repository_afo_register.py

@@ -0,0 +1,23 @@
+from ebl.common.query.query_schemas import (
+    AfORegisterToFragmentQueryResultSchema,
+)
+from ebl.tests.factories.fragment import (
+    FragmentFactory,
+)
+from ebl.common.query.query_schemas import (
+    AfORegisterToFragmentQueryResultSchema,
+)
+
+def test_query_fragmentarium_afo_register(
+    fragment_repository
+):
+    fragment = FragmentFactory.build(
+        traditional_references = []
+    )
+
+    # ToDo: Add data to test
+
+    fragment_repository.create_many([fragment, FragmentFactory.build()])
+
+    result = fragment_repository.query_by_traditional_references([])
+    assert result == AfORegisterToFragmentQueryResultSchema().load({"items": []})