Looping 2.5 | Repeating Blocks for List Items

app/data_models/progress_store.py

@@ -4,7 +4,7 @@
 from app.data_models.progress import Progress, ProgressDictType
 from app.questionnaire.location import Location
 
-SectionKeyType = tuple[str, Optional[str]]
+ProgressKeyType = tuple[str, Optional[str]]
 
 
 @dataclass
@@ -20,34 +20,42 @@ def __iter__(self) -> Iterator[tuple[str]]:
 
 class ProgressStore:
     """
-    An object that stores and updates references to sections and blocks
+    An object that stores and updates references to sections and list items
     that have been started.
     """
 
     def __init__(
-        self, in_progress_sections: Optional[Iterable[ProgressDictType]] = None
+        self,
+        in_progress_sections_and_list_items: Iterable[ProgressDictType] | None = None,
     ) -> None:
         """
-        Instantiate a ProgressStore object that tracks the status of sections and its completed blocks
+        Instantiate a ProgressStore object that tracks the progress status of sections and list items,
+            and their completed blocks.
+            - Standard Sections are keyed by Section ID, and a None List Item ID
+            - Repeating Sections (dynamic Sections created for List Items) are keyed by their randomly generated
+                Section ID, and their List Item ID
+            - List Items are keyed by the Section ID for the Section in which their List Collector appears,
+                and the List Item ID.
         Args:
-            in_progress_sections: A list of hierarchical dict containing the section status and completed blocks
+            in_progress_sections_and_list_items: A list of hierarchical dict containing the completion status
+                and completed blocks
         """
         self._is_dirty: bool = False
         self._is_routing_backwards: bool = False
-        self._progress: MutableMapping[SectionKeyType, Progress] = self._build_map(
-            in_progress_sections or []
+        self._progress: MutableMapping[ProgressKeyType, Progress] = self._build_map(
+            in_progress_sections_and_list_items or []
         )
 
-    def __contains__(self, section_key: SectionKeyType) -> bool:
-        return section_key in self._progress
+    def __contains__(self, progress_key: ProgressKeyType) -> bool:
+        return progress_key in self._progress
 
     @staticmethod
-    def _build_map(section_progress_list: Iterable[ProgressDictType]) -> MutableMapping:
+    def _build_map(progress_list: Iterable[ProgressDictType]) -> MutableMapping:
         """
         Builds the progress_store's data structure from a list of progress dictionaries.
 
-        The `section_key` is tuple consisting of `section_id` and the `list_item_id`.
-        The `section_progress` is a mutableMapping created from the Progress object.
+        The `progress_key` is tuple consisting of `section_id` and the `list_item_id`.
+        The `progress` is a mutableMapping created from the Progress object.
 
         Example structure:
         {
@@ -62,10 +70,10 @@ def _build_map(section_progress_list: Iterable[ProgressDictType]) -> MutableMapp
 
         return {
             (
-                section_progress["section_id"],
-                section_progress.get("list_item_id"),
-            ): Progress.from_dict(section_progress)
-            for section_progress in section_progress_list
+                progress["section_id"],
+                progress.get("list_item_id"),
+            ): Progress.from_dict(progress)
+            for progress in progress_list
         }
 
     @property
@@ -76,87 +84,97 @@ def is_dirty(self) -> bool:
     def is_routing_backwards(self) -> bool:
         return self._is_routing_backwards
 
-    def is_section_complete(
-        self, section_id: str, list_item_id: Optional[str] = None
+    def is_section_or_list_item_complete(
+        self, section_id: str, list_item_id: str | None = None
     ) -> bool:
-        return (section_id, list_item_id) in self.section_keys(
+        """
+        Return True if the CompletionStatus of the Section or List Item specified by the given section_id and
+         list_item_id is COMPLETED or INDIVIDUAL_RESPONSE_REQUESTED, else False.
+        """
+        return (section_id, list_item_id) in self.progress_keys(
             statuses={
                 CompletionStatus.COMPLETED,
                 CompletionStatus.INDIVIDUAL_RESPONSE_REQUESTED,
             }
         )
 
-    def section_keys(
+    def progress_keys(
         self,
-        statuses: Optional[Iterable[str]] = None,
-        section_ids: Optional[Iterable[str]] = None,
-    ) -> list[SectionKeyType]:
+        statuses: Iterable[str] | None = None,
+        section_ids: Iterable[str] | None = None,
+    ) -> list[ProgressKeyType]:
         if not statuses:
             statuses = {*CompletionStatus()}
 
-        section_keys = [
+        progress_keys = [
             section_key
             for section_key, section_progress in self._progress.items()
             if section_progress.status in statuses
         ]
 
         if section_ids is None:
-            return section_keys
+            return progress_keys
 
         return [
-            section_key
-            for section_key in section_keys
-            if any(section_id in section_key for section_id in section_ids)
+            progress_key
+            for progress_key in progress_keys
+            if any(section_id in progress_key for section_id in section_ids)
         ]
 
-    def update_section_status(
-        self, section_status: str, section_id: str, list_item_id: Optional[str] = None
+    def update_section_or_list_item_completion_status(
+        self,
+        completion_status: str,
+        section_id: str,
+        list_item_id: str | None = None,
     ) -> bool:
+        """
+        Updates the completion status of the section or list item specified by the key based on the given section id and list item id.
+        """
         updated = False
         section_key = (section_id, list_item_id)
         if section_key in self._progress:
-            if self._progress[section_key].status != section_status:
+            if self._progress[section_key].status != completion_status:
                 updated = True
-                self._progress[section_key].status = section_status
+                self._progress[section_key].status = completion_status
                 self._is_dirty = True
 
-        elif section_status == CompletionStatus.INDIVIDUAL_RESPONSE_REQUESTED:
+        elif completion_status == CompletionStatus.INDIVIDUAL_RESPONSE_REQUESTED:
             self._progress[section_key] = Progress(
                 section_id=section_id,
                 list_item_id=list_item_id,
                 block_ids=[],
-                status=section_status,
+                status=completion_status,
             )
             self._is_dirty = True
 
         return updated
 
-    def get_section_status(
-        self, section_id: str, list_item_id: Optional[str] = None
+    def get_section_or_list_item_status(
+        self, section_id: str, list_item_id: str | None = None
     ) -> str:
-        section_key = (section_id, list_item_id)
-        if section_key in self._progress:
-            return self._progress[section_key].status
+        progress_key = (section_id, list_item_id)
+        if progress_key in self._progress:
+            return self._progress[progress_key].status
 
         return CompletionStatus.NOT_STARTED
 
     def get_block_status(
         self, *, block_id: str, section_id: str, list_item_id: str | None = None
     ) -> str:
-        section_blocks = self.get_completed_block_ids(
+        section_or_list_item_blocks = self.get_completed_block_ids(
             section_id=section_id, list_item_id=list_item_id
         )
-        if block_id in section_blocks:
+        if block_id in section_or_list_item_blocks:
             return CompletionStatus.COMPLETED
 
         return CompletionStatus.NOT_STARTED
 
     def get_completed_block_ids(
         self, *, section_id: str, list_item_id: str | None = None
     ) -> list[str]:
-        section_key = (section_id, list_item_id)
-        if section_key in self._progress:
-            return self._progress[section_key].block_ids
+        progress_key = (section_id, list_item_id)
+        if progress_key in self._progress:
+            return self._progress[progress_key].block_ids
 
         return []
 
@@ -171,12 +189,12 @@ def add_completed_location(self, location: Location) -> None:
         if location.block_id not in completed_block_ids:
             completed_block_ids.append(location.block_id)  # type: ignore
 
-            section_key = (section_id, list_item_id)
+            progress_key = (section_id, list_item_id)
 
-            if section_key in self._progress:
-                self._progress[section_key].block_ids = completed_block_ids
+            if progress_key in self._progress:
+                self._progress[progress_key].block_ids = completed_block_ids
             else:
-                self._progress[section_key] = Progress(
+                self._progress[progress_key] = Progress(
                     section_id=section_id,
                     list_item_id=list_item_id,
                     block_ids=completed_block_ids,
@@ -186,15 +204,15 @@ def add_completed_location(self, location: Location) -> None:
             self._is_dirty = True
 
     def remove_completed_location(self, location: Location) -> bool:
-        section_key = (location.section_id, location.list_item_id)
+        progress_key = (location.section_id, location.list_item_id)
         if (
-            section_key in self._progress
-            and location.block_id in self._progress[section_key].block_ids
+            progress_key in self._progress
+            and location.block_id in self._progress[progress_key].block_ids
         ):
-            self._progress[section_key].block_ids.remove(location.block_id)
+            self._progress[progress_key].block_ids.remove(location.block_id)
 
-            if not self._progress[section_key].block_ids:
-                self._progress[section_key].status = CompletionStatus.IN_PROGRESS
+            if not self._progress[progress_key].block_ids:
+                self._progress[progress_key].status = CompletionStatus.IN_PROGRESS
 
             self._is_dirty = True
             return True
@@ -208,14 +226,14 @@ def remove_progress_for_list_item_id(self, list_item_id: str) -> None:
         *Not efficient.*
         """
 
-        section_keys_to_delete = [
+        progress_keys_to_delete = [
             (section_id, progress_list_item_id)
             for section_id, progress_list_item_id in self._progress
             if progress_list_item_id == list_item_id
         ]
 
-        for section_key in section_keys_to_delete:
-            del self._progress[section_key]
+        for progress_key in progress_keys_to_delete:
+            del self._progress[progress_key]
 
             self._is_dirty = True
 
@@ -231,9 +249,9 @@ def clear(self) -> None:
         self._is_dirty = True
 
     def started_section_keys(
-        self, section_ids: Optional[Iterable[str]] = None
-    ) -> list[SectionKeyType]:
-        return self.section_keys(
+        self, section_ids: Iterable[str] | None = None
+    ) -> list[ProgressKeyType]:
+        return self.progress_keys(
             statuses={CompletionStatus.COMPLETED, CompletionStatus.IN_PROGRESS},
             section_ids=section_ids,
         )

app/jinja_filters.py

@@ -583,7 +583,6 @@ def map_summary_item_config(
     calculated_question: Optional[dict[str, list]],
     remove_link_text: str | None = None,
     remove_link_aria_label: str | None = None,
-    icon: Optional[str] = None,
 ) -> list[Union[dict[str, list], SummaryRow]]:
     rows: list[Union[dict[str, list], SummaryRow]] = []
 
@@ -613,7 +612,6 @@ def map_summary_item_config(
         else:
             list_collector_rows = map_list_collector_config(
                 list_items=block["list"]["list_items"],
-                icon=icon,
                 edit_link_text=edit_link_text,
                 edit_link_aria_label=edit_link_aria_label,
                 remove_link_text=remove_link_text,
@@ -639,17 +637,17 @@ def map_summary_item_config_processor() -> dict[str, Callable]:
 # pylint: disable=too-many-locals
 @blueprint.app_template_filter()  # type: ignore
 def map_list_collector_config(
-    list_items: list[dict[str, Union[str, int]]],
-    icon: Optional[str],
+    list_items: list[dict[str, str | int]],
+    render_icon: bool = False,
     edit_link_text: str = "",
     edit_link_aria_label: str = "",
-    remove_link_text: Optional[str] = None,
-    remove_link_aria_label: Optional[str] = None,
-    related_answers: Optional[dict] = None,
-    item_label: Optional[str] = None,
-    item_anchor: Optional[str] = None,
-) -> list[Union[dict[str, list], SummaryRow]]:
-    rows: list[Union[dict[str, list], SummaryRow]] = []
+    remove_link_text: str | None = None,
+    remove_link_aria_label: str | None = None,
+    related_answers: dict | None = None,
+    item_label: str | None = None,
+    item_anchor: str | None = None,
+) -> list[dict[str, list] | SummaryRow]:
+    rows: list[dict[str, list] | SummaryRow] = []
 
     for index, list_item in enumerate(list_items, start=1):
         item_name = list_item.get("item_title")
@@ -695,6 +693,14 @@ def map_list_collector_config(
                 }
             )
 
+        icon = (
+            "check"
+            if render_icon
+            and list_item.get("repeating_blocks")
+            and list_item.get("is_complete")
+            else None
+        )
+
         row_item = {
             "iconType": icon,
             "actions": actions,

app/questionnaire/path_finder.py

@@ -276,7 +276,7 @@ def _remove_current_blocks_answers_for_backwards_routing(
                 )
 
             self.progress_store.remove_location_for_backwards_routing(this_location)
-            self.progress_store.update_section_status(
+            self.progress_store.update_section_or_list_item_completion_status(
                 CompletionStatus.IN_PROGRESS, this_location.section_id
             )
 

app/questionnaire/questionnaire_schema.py

@@ -23,6 +23,7 @@
     "ListEditQuestion",
     "ListRemoveQuestion",
     "PrimaryPersonListAddOrEditQuestion",
+    "ListRepeatingBlock",
 ]
 
 RELATIONSHIP_CHILDREN = ["UnrelatedQuestion"]
@@ -81,6 +82,7 @@ def __init__(
         ] = defaultdict(set)
         self._language_code = language_code
         self._questionnaire_json = questionnaire_json
+        self._repeating_blocks_by_id: dict[str, ImmutableDict] = {}
         self.dynamic_answers_parent_block_ids: set[str] = set()
 
         # The ordering here is required as they depend on each other.
@@ -290,6 +292,14 @@ def _get_blocks_by_id(self) -> dict[str, ImmutableDict]:
                             nested_block_id = nested_block["id"]
                             blocks[nested_block_id] = nested_block
                             self._parent_id_map[nested_block_id] = block_id
+                    if repeating_blocks := block.get("repeating_blocks"):
+                        for repeating_block in repeating_blocks:
+                            repeating_block_id = repeating_block["id"]
+                            blocks[repeating_block_id] = repeating_block
+                            self._parent_id_map[repeating_block_id] = block_id
+                            self._repeating_blocks_by_id[
+                                repeating_block_id
+                            ] = repeating_block
 
         return blocks
 
@@ -707,6 +717,9 @@ def get_first_block_id_for_section(self, section_id: str) -> str | None:
     def get_blocks(self) -> Iterable[ImmutableDict]:
         return self._blocks_by_id.values()
 
+    def get_repeating_blocks(self) -> dict[str, ImmutableDict]:
+        return self._repeating_blocks_by_id
+
     def get_block(self, block_id: str) -> ImmutableDict | None:
         return self._blocks_by_id.get(block_id)
 
@@ -988,7 +1001,11 @@ def _block_for_answer(self, answer_id: str) -> ImmutableDict | None:
         parent_block_id = self._parent_id_map[block_id]
         parent_block = self.get_block(parent_block_id)
 
-        if parent_block and parent_block["type"] == "ListCollector":
+        if (
+            parent_block
+            and parent_block["type"] == "ListCollector"
+            and block_id not in self._repeating_blocks_by_id
+        ):
             return parent_block
 
         return self.get_block(block_id)