Release 7.4.0 -> main

.platform.app.yaml

@@ -60,7 +60,7 @@ hooks:
 
     npm install
     npm install -g sass
-    sass sass/etna.scss:templates/static/css/dist/etna.css
+    sass --quiet-deps --style=compressed --load-path=node_modules sass/etna.scss:templates/static/css/dist/etna.css
 
     npx webpack --config webpack.config.js
 

codecov.yml

@@ -0,0 +1 @@
+comment: false

config/settings/base.py

@@ -278,6 +278,10 @@
 
 WAGTAILIMAGES_IMAGE_MODEL = "images.CustomImage"
 
+# Custom password template for private pages
+
+PASSWORD_REQUIRED_TEMPLATE = "password_pages/password_required.html"
+
 # Kong client
 
 KONG_CLIENT_BASE_URL = os.getenv("KONG_CLIENT_BASE_URL")

etna/articles/models.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Tuple
+from typing import Any, Dict, List, Tuple, Union
 
 from django.conf import settings
 from django.db import models
@@ -252,7 +252,9 @@ def save(self, *args, **kwargs):
         super().save(*args, **kwargs)
 
     @cached_property
-    def similar_items(self) -> Tuple["ArticlePage"]:
+    def similar_items(
+        self,
+    ) -> Tuple[Union["ArticlePage", "FocusedArticlePage", "RecordArticlePage"], ...]:
         """
         Returns a maximum of three ArticlePages that are tagged with at least
         one of the same ArticleTags. Items should be ordered by the number
@@ -267,49 +269,43 @@ def similar_items(self) -> Tuple["ArticlePage"]:
             # Avoid unncecssary lookups
             return ()
 
-        # Identify 'other' live pages with tags in common
-        tag_match_ids = (
-            ArticlePage.objects.public()
-            .live()
+        # Identify other live pages with tags in common
+        related_tags = (
+            Page.objects.live()
+            .public()
             .not_page(self)
+            .exact_type(ArticlePage, FocusedArticlePage, RecordArticlePage)
             .filter(tagged_items__tag_id__in=tag_ids)
-            .values_list("id", flat=True)
-            .distinct()
         )
-        if not tag_match_ids:
-            # Avoid unncecssary lookups
-            return ()
 
-        # Use search() to prioritise items with the highest number of matches
         return tuple(
-            ArticlePage.objects.filter(id__in=tag_match_ids).search(
-                self.article_tag_names,
-                fields=["article_tag_names"],
-                operator="or",
-            )[:3]
+            Page.objects.filter(id__in=related_tags).order_by("-first_published_at")[:3]
         )
 
     @cached_property
-    def latest_items(self) -> Tuple["ArticlePage"]:
+    def latest_items(
+        self,
+    ) -> List[Union["ArticlePage", "FocusedArticlePage", "RecordArticlePage"]]:
         """
         Return the three most recently published ArticlePages,
         excluding this object.
         """
-        similarqueryset = list(self.similar_items)
-
-        latestqueryset = list(
-            ArticlePage.objects.public()
-            .live()
-            .not_page(self)
-            .select_related("hero_image")
-            .prefetch_related("hero_image__renditions")
-            .order_by("-first_published_at")
-        )
-        filterlatestpages = [
-            page for page in latestqueryset if page not in similarqueryset
-        ]
 
-        return tuple(filterlatestpages[:3])
+        latest_query_set = []
+
+        for page_type in [ArticlePage, FocusedArticlePage, RecordArticlePage]:
+            latest_query_set.extend(
+                page_type.objects.live()
+                .public()
+                .exclude(id__in=[page.id for page in self.similar_items])
+                .not_page(self)
+                .select_related("teaser_image")
+                .prefetch_related("teaser_image__renditions")
+            )
+
+        return sorted(
+            latest_query_set, key=lambda x: x.first_published_at, reverse=True
+        )[:3]
 
 
 class FocusedArticlePage(

etna/articles/tests/test_similar_items.py

@@ -71,16 +71,16 @@ def setUp(self):
         self.different_tags_page.save()
 
     def test_similar_items_ranking(self):
-        # Items should be in 'best match' order
+        # Items should be in 'most recent' order
         # No draft items should be included
         test_page = ArticlePage.objects.get(id=self.original_page.id)
-        with self.assertNumQueries(4):
+        with self.assertNumQueries(3):
             self.assertEqual(
-                list(test_page.similar_items),
+                list(page.id for page in test_page.similar_items),
                 [
-                    self.three_matches_page,
-                    self.two_matches_page,
-                    self.single_match_page,
+                    self.three_matches_page.id,
+                    self.two_matches_page.id,
+                    self.single_match_page.id,
                 ],
             )
 
@@ -98,5 +98,5 @@ def test_further_queries_prevented_when_no_tags_available(self):
 
     def test_search_prevented_if_no_tag_matches_identified(self):
         test_page = ArticlePage.objects.get(id=self.different_tags_page.id)
-        with self.assertNumQueries(3):
+        with self.assertNumQueries(4):
             self.assertFalse(test_page.similar_items)

etna/ciim/constants.py

@@ -666,6 +666,21 @@ class LevelKeys(StrEnum):
     LEVEL_7 = "Item"
 
 
+@forTemplate
+class NonTNALevelKeys(StrEnum):
+    LEVEL_1 = "Fonds"
+    LEVEL_2 = "Sub-fonds"
+    LEVEL_3 = "Sub-sub-fonds"
+    LEVEL_4 = "Sub-sub-sub-fonds"
+    LEVEL_5 = "Series"
+    LEVEL_6 = "Sub-series"
+    LEVEL_7 = "Sub-sub-series"
+    LEVEL_8 = "Sub-sub-sub-series"
+    LEVEL_9 = "File"
+    LEVEL_10 = "Item"
+    LEVEL_11 = "Sub-item"
+
+
 LEVELS = (
     "Division",
     "Lettercode",
@@ -749,3 +764,8 @@ class Display(StrEnum):
         "long_display_name": "Paper catalogues available to view at The National Archives",
     },
 ]
+
+CLOSURE_CLOSED_STATUS = [
+    "Closed Or Retained Document, Closed Description",
+    "Closed Or Retained Document, Open Description",
+]

etna/records/field_labels.py

@@ -16,4 +16,5 @@
     "related_records": "Related records",
     "related_articles": "Related content",
     "related_materials": "Related material",
+    "closure": "Closure Status",
 }

etna/records/models.py

@@ -92,6 +92,13 @@ def iaid(self) -> str:
         except KeyError:
             candidate = self.get("@admin.id", default="")
 
+        try:
+            # fallback for Record Creators
+            if not candidate:
+                candidate = self.template["primaryIdentifier"]
+        except KeyError:
+            candidate = ""
+
         if candidate and re.match(IAIDConverter.regex, candidate):
             # value is not guaranteed to be a valid 'iaid', so we must
             # check it before returning it as one
@@ -713,6 +720,191 @@ def archive_accessions(self) -> Optional[AccessionsInfo]:
     def archive_repository_url(self) -> str:
         return self.get("repository.url", "")
 
+    @cached_property
+    def alternative_names(self) -> tuple(dict):
+        alternative_names = ()
+        if names := self.get("name", ()):
+            for item in names:
+                if type := item.get("type", ""):
+                    if type in (
+                        "maiden name",
+                        "also known as",
+                        "formerly known as",
+                        "later known as",
+                        "pseudonym",
+                        "relation of",
+                        "real name",
+                        "standardised form of name according to other rules",
+                    ):
+                        alternative_names += (
+                            {
+                                "label": type.capitalize(),
+                                "value": item.get("value", ""),
+                            },
+                        )
+                    elif type == "unknown / other":
+                        alternative_names += (
+                            {"label": type.title(), "value": item.get("value", "")},
+                        )
+
+        return alternative_names
+
+    @cached_property
+    def first_name(self) -> str:
+        first_name = ""
+        if name_data := self.get("name", ()):
+            for item in name_data:
+                if first_name_list := item.get("first_name"):
+                    first_name = " ".join(first_name_list)
+        return first_name
+
+    @cached_property
+    def last_name(self) -> str:
+        if name_data := self.get("name", ()):
+            for item in name_data:
+                if last_name := item.get("last_name", ""):
+                    return last_name
+        return ""
+
+    @cached_property
+    def title_prefix(self) -> str:
+        if name_data := self.get("name", ()):
+            for item in name_data:
+                if title_prefix := item.get("title_prefix"):
+                    return title_prefix
+        return ""
+
+    @cached_property
+    def title_for_name(self) -> str:
+        if name_data := self.get("name", ()):
+            for item in name_data:
+                if title := item.get("title"):
+                    return title
+        return ""
+
+    @cached_property
+    def gender(self) -> str:
+        if gender := self.get("gender", ""):
+            if gender == "M":
+                return "Male"
+            elif gender == "F":
+                return "Female"
+            logger.debug(
+                f"Gender value={gender} could not be translated for iaid={self.iaid}"
+            )
+        return gender
+
+    @cached_property
+    def history(self) -> str:
+        if description := self.get("description", ()):
+            for item in description:
+                if item.get("type") == "history":
+                    if value := item.get("value", ""):
+                        return mark_safe(value)
+        return ""
+
+    @cached_property
+    def biography(self) -> dict:
+        if description := self.get("description", ()):
+            for item in description:
+                if item.get("type") == "biography":
+                    return {"value": item.get("value", ""), "url": item.get("url", "")}
+        return {}
+
+    @cached_property
+    def func_occup_activ(self) -> str:
+        if description := self.get("description", ()):
+            for item in description:
+                if item.get("type") == "functions, occupations and activities":
+                    if value := item.get("value", ""):
+                        document = pq(value)
+                        for tag in ("foa", "function"):
+                            if doc_value := document(tag).text():
+                                return doc_value
+                        return value
+        return ""
+
+    @cached_property
+    def places(self) -> tuple(str):
+        places = ()
+        if place := self.get("place", ()):
+            for item in place:
+                if name := item.get("name", ()):
+                    for item in name:
+                        if value := item.get("value", ""):
+                            places += (value,)
+        return places
+
+    @cached_property
+    def birth_date(self) -> str:
+        return extract(self.get("birth", {}), "date.value", default="")
+
+    @cached_property
+    def death_date(self) -> str:
+        return extract(self.get("death", {}), "date.value", default="")
+
+    @cached_property
+    def start_date(self) -> str:
+        if date := extract(self.get("start", {}), "date", default=()):
+            for item in date:
+                if value := item.get("value", ""):
+                    return value
+        return ""
+
+    @cached_property
+    def end_date(self) -> str:
+        if date := extract(self.get("end", {}), "date", default=()):
+            for item in date:
+                if value := item.get("value", ""):
+                    return value
+        return ""
+
+    @cached_property
+    def record_creators_date(self) -> str:
+        """
+        Returns dates for person, person's activity/service,  both, or any if available
+        """
+        separator = "-"
+        joiner = "; "
+        person_date = service_activity_date = ""
+        if self.birth_date and self.death_date:
+            person_date = f"{self.birth_date}{separator}{self.death_date}"
+        else:
+            person_date = self.birth_date or self.death_date
+
+        if self.start_date and self.end_date:
+            service_activity_date = f"{self.start_date}{separator}{self.end_date}"
+        else:
+            service_activity_date = self.start_date or self.end_date
+
+        # return self.birth_date or self.death_date or self.start_date or self.end_date
+        if person_date and service_activity_date:
+            return joiner.join([person_date, service_activity_date])
+
+        return person_date or service_activity_date
+
+    @cached_property
+    def name_authority_reference(self) -> str:
+        if identifier := self.get("identifier", ()):
+            for item in identifier:
+                if name_authority_reference := item.get("name_authority_reference", ""):
+                    return name_authority_reference
+        return ""
+
+    @cached_property
+    def former_name_authority_reference(self) -> str:
+        if identifier := self.get("identifier", ()):
+            for item in identifier:
+                if former_name_authority_reference := item.get(
+                    "former_name_authority_reference", ""
+                ):
+                    return former_name_authority_reference
+        return ""
+
+    @cached_property
+    def closure_status(self) -> str:
+        return extract(self.get("@template", {}), "details.closureStatus", default="")
+
 
 @dataclass
 class Image: