Implement "progress" value source

app/data_models/progress_store.py

@@ -138,8 +138,19 @@ def get_section_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_id=section_id, list_item_id=list_item_id
+        )
+        if block_id in section_blocks:
+            return CompletionStatus.COMPLETED
+
+        return CompletionStatus.NOT_STARTED
+
     def get_completed_block_ids(
-        self, section_id: str, list_item_id: Optional[str] = None
+        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:
@@ -151,7 +162,9 @@ def add_completed_location(self, location: Location) -> None:
         section_id = location.section_id
         list_item_id = location.list_item_id
 
-        completed_block_ids = self.get_completed_block_ids(section_id, list_item_id)
+        completed_block_ids = self.get_completed_block_ids(
+            section_id=section_id, list_item_id=list_item_id
+        )
 
         if location.block_id not in completed_block_ids:
             completed_block_ids.append(location.block_id)  # type: ignore

app/publisher/publisher.py

@@ -2,6 +2,7 @@
 
 import google.auth
 from google.cloud.pubsub import PublisherClient
+from google.cloud.pubsub_v1 import publisher
 from google.cloud.pubsub_v1.futures import Future
 from structlog import get_logger
 
@@ -21,7 +22,7 @@ def __init__(self):
         self._client = PublisherClient()
         _, self._project_id = google.auth.default()
 
-    def _publish(self, topic_id, message):
+    def _publish(self, topic_id, message) -> "publisher.futures.Future":
         logger.info("publishing message", topic_id=topic_id)
         # pylint: disable=no-member
         topic_path = self._client.topic_path(self._project_id, topic_id)

app/questionnaire/path_finder.py

@@ -44,7 +44,7 @@ def routing_path(
 
         if section:
             when_rules_block_dependencies = self.get_when_rules_block_dependencies(
-                section["id"]
+                section_id
             )
             blocks = self._get_not_skipped_blocks_in_section(
                 current_location,
@@ -64,11 +64,13 @@ def get_when_rules_block_dependencies(self, section_id: str) -> list[str]:
         """NB: At present when rules block dependencies does not fully support repeating sections.
         It is supported when the section is dependent i.e the current section is repeating and building the routing path for sections that are not,
         It isn't supported if it needs to build the path for repeating sections"""
+        dependencies_for_section = (
+            self.schema.get_all_when_rules_section_dependencies_for_section(section_id)
+        )
+
         return [
             block_id
-            for dependent_section in self.schema.when_rules_section_dependencies_by_section.get(
-                section_id, {}
-            )
+            for dependent_section in dependencies_for_section
             for block_id in self.routing_path(dependent_section)
             if (dependent_section, None) in self.progress_store.started_section_keys()
         ]
@@ -191,9 +193,9 @@ def _evaluate_routing_rules(
             self.list_store,
             self.metadata,
             self.response_metadata,
+            progress_store=self.progress_store,
             location=this_location,
             routing_path_block_ids=routing_path_block_ids,
-            progress_store=self.progress_store,
         )
         for rule in routing_rules:
             rule_valid = (

app/questionnaire/questionnaire_schema.py

@@ -11,7 +11,7 @@
 from app.forms import error_messages
 from app.questionnaire.rules.operator import OPERATION_MAPPING
 from app.utilities.make_immutable import make_immutable
-from app.utilities.mappings import get_mappings_with_key
+from app.utilities.mappings import get_flattened_mapping_values, get_mappings_with_key
 
 DEFAULT_LANGUAGE_CODE = "en"
 
@@ -58,6 +58,12 @@ def __init__(
             set
         )
         self._when_rules_section_dependencies_by_section: dict[str, set[str]] = {}
+        self._when_rules_section_dependencies_by_section_for_progress_value_source: dict[
+            str, list[str]
+        ] = {}
+        self._when_rules_block_dependencies_by_section_for_progress_value_source: dict[
+            str, dict[str, list[str]]
+        ] = {}
         self.calculated_summary_section_dependencies_by_block: dict[
             str, dict[str, set[str]]
         ] = defaultdict(lambda: defaultdict(set))
@@ -89,6 +95,22 @@ def when_rules_section_dependencies_by_section(
     ) -> ImmutableDict[str, set[str]]:
         return ImmutableDict(self._when_rules_section_dependencies_by_section)
 
+    @cached_property
+    def when_rules_section_dependencies_by_section_for_progress_value_source(
+        self,
+    ) -> ImmutableDict[str, list[str]]:
+        return ImmutableDict(
+            self._when_rules_section_dependencies_by_section_for_progress_value_source
+        )
+
+    @cached_property
+    def when_rules_block_dependencies_by_section_for_progress_value_source(
+        self,
+    ) -> ImmutableDict[str, dict[str, list[str]]]:
+        return ImmutableDict(
+            self._when_rules_block_dependencies_by_section_for_progress_value_source
+        )
+
     @cached_property
     def when_rules_section_dependencies_by_answer(self) -> ImmutableDict[str, set[str]]:
         return ImmutableDict(self._when_rules_section_dependencies_by_answer)
@@ -166,6 +188,28 @@ def is_view_submitted_response_enabled(self) -> bool:
         is_enabled: bool = schema.get("view_response", False)
         return is_enabled
 
+    def get_all_when_rules_section_dependencies_for_section(
+        self, section_id: str
+    ) -> set[str]:
+        section_dependencies = self.when_rules_section_dependencies_by_section_for_progress_value_source.get(
+            section_id, []
+        )
+        progress_section_dependencies = set(section_dependencies)
+
+        all_section_dependencies = self.when_rules_section_dependencies_by_section.get(
+            section_id, set()
+        ).union(progress_section_dependencies)
+
+        block_dependencies: dict = (
+            self.when_rules_block_dependencies_by_section_for_progress_value_source.get(
+                section_id, {}
+            )
+        )
+
+        section_ids = get_flattened_mapping_values(block_dependencies)
+
+        return all_section_dependencies.union(section_ids)
+
     def _get_sections_by_id(self) -> dict[str, ImmutableDict]:
         return {section["id"]: section for section in self.json.get("sections", [])}
 
@@ -839,17 +883,113 @@ def _populate_when_rules_section_dependencies(self) -> None:
             when_rules = self.get_values_for_key(section, "when")
             rules: list = list(when_rules)
 
-            if rules_section_dependencies := self._get_rules_section_dependencies(
-                section["id"], rules
-            ):
+            (
+                rules_section_dependencies,
+                rule_section_dependencies_for_progress_value_source,
+                rule_block_dependencies_for_progress_value_source,
+            ) = self._get_rules_section_dependencies(section["id"], rules)
+
+            if rules_section_dependencies:
                 self._when_rules_section_dependencies_by_section[
                     section["id"]
                 ] = rules_section_dependencies
 
+            if rule_section_dependencies_for_progress_value_source:
+                for key in rule_section_dependencies_for_progress_value_source:
+                    if (
+                        key
+                        in self._when_rules_section_dependencies_by_section_for_progress_value_source
+                    ):
+                        self._when_rules_section_dependencies_by_section_for_progress_value_source[
+                            key
+                        ].append(
+                            *rule_section_dependencies_for_progress_value_source[key]
+                        )
+                    else:
+                        self._when_rules_section_dependencies_by_section_for_progress_value_source[
+                            key
+                        ] = rule_section_dependencies_for_progress_value_source[
+                            key
+                        ]
+
+            if rule_block_dependencies_for_progress_value_source:
+                self._populate_block_dependencies_for_progress_value_source(
+                    rule_block_dependencies_for_progress_value_source
+                )
+
+    def _populate_block_dependencies_for_progress_value_source(
+        self,
+        rule_block_dependencies_for_progress_value_source: dict[
+            str, dict[str, list[str]]
+        ],
+    ) -> None:
+        dependencies = (
+            self._when_rules_block_dependencies_by_section_for_progress_value_source
+        )
+
+        for (
+            dependent_section,
+            section_dependencies_by_block,
+        ) in rule_block_dependencies_for_progress_value_source.items():
+            if dependent_section in dependencies:
+                for block_id, section_ids in section_dependencies_by_block.items():
+                    if block_id in dependencies[dependent_section]:
+                        dependencies[dependent_section][block_id].extend(section_ids)
+            else:
+                dependencies[
+                    dependent_section
+                ] = rule_block_dependencies_for_progress_value_source[dependent_section]
+
+    def _get_section_and_block_ids_dependencies_for_progress_source_and_answer_ids_from_rule(
+        self, current_section_id: str, rule: Mapping
+    ) -> tuple[set[str], dict[str, dict[str, list[str] | dict[str, list[str]]]]]:
+        answer_id_list: set[str] = set()
+        dependencies_ids_for_progress_value_source: dict[
+            str, dict[str, list[str] | dict[str, list[str]]]
+        ] = {
+            "sections": {},
+            "blocks": {},
+        }
+        identifier: str | None = rule.get("identifier")
+        source: str | None = rule.get("source")
+        selector: str | None = rule.get("selector")
+
+        if source == "answers" and identifier:
+            answer_id_list.add(identifier)
+        elif source == "calculated_summary" and identifier:
+            calculated_summary_block = self.get_block(identifier)
+            # Type Ignore: Calculated summary block will exist at this point
+            calculated_summary_answer_ids = get_calculated_summary_answer_ids(
+                calculated_summary_block  # type: ignore
+            )
+            answer_id_list.update(calculated_summary_answer_ids)
+        elif source == "progress" and identifier and selector:
+            if selector == "section":
+                if identifier != current_section_id:
+                    dependencies_ids_for_progress_value_source["sections"][
+                        identifier
+                    ] = [current_section_id]
+            elif selector == "block" and (
+                section_id := self.get_section_id_for_block_id(identifier)
+            ):
+                # Type ignore: The identifier key will return a list
+                if section_id != current_section_id:
+                    dependencies_ids_for_progress_value_source["blocks"][section_id] = {
+                        identifier: []
+                    }
+                    dependencies_ids_for_progress_value_source["blocks"][section_id][identifier].append(current_section_id)  # type: ignore
+
+        return answer_id_list, dependencies_ids_for_progress_value_source
+
     def _get_rules_section_dependencies(
-        self, current_section_id: str, rules: Union[Mapping, Sequence]
-    ) -> set[str]:
-        rules_section_dependencies: set[str] = set()
+        self, current_section_id: str, rules: Mapping | Sequence
+    ) -> tuple[set[str], dict[str, list[str]], dict[str, dict[str, list[str]]]]:
+        """
+        Returns a set of sections ids that the current sections depends on.
+        """
+        section_dependencies: set[str] = set()
+        section_dependencies_for_progress_value_source: dict = {}
+        block_dependencies_for_progress_value_source: dict = {}
 
         if isinstance(rules, Mapping) and QuestionnaireSchema.has_operator(rules):
             rules = self.get_operands(rules)
@@ -858,18 +998,21 @@ def _get_rules_section_dependencies(
             if not isinstance(rule, Mapping):
                 continue
 
-            answer_id_list: list = []
-            identifier: Optional[str] = rule.get("identifier")
-            source: Optional[str] = rule.get("source")
-
-            if source == "answers" and identifier:
-                answer_id_list.append(identifier)
-            elif source == "calculated_summary" and identifier:
-                calculated_summary_block = self.get_block(identifier)
-                calculated_summary_answer_ids = get_calculated_summary_answer_ids(
-                    calculated_summary_block  # type: ignore
-                )
-                answer_id_list.extend(iter(calculated_summary_answer_ids))
+            [
+                answer_id_list,
+                dependencies_for_progress_value_source,
+            ] = self._get_section_and_block_ids_dependencies_for_progress_source_and_answer_ids_from_rule(
+                current_section_id, rule
+            )
+
+            section_dependencies_for_progress_value_source |= (
+                dependencies_for_progress_value_source["sections"]
+            )
+            block_dependencies_for_progress_value_source |= (
+                dependencies_for_progress_value_source["blocks"]
+            )
+
+            # Type Ignore: Added to this method as the block will exist at this point
             for answer_id in answer_id_list:
                 block = self.get_block_for_answer_id(answer_id)  # type: ignore
                 section_id = self.get_section_id_for_block_id(block["id"])  # type: ignore
@@ -878,14 +1021,27 @@ def _get_rules_section_dependencies(
                     self._when_rules_section_dependencies_by_answer[answer_id].add(
                         current_section_id
                     )
-                    rules_section_dependencies.add(section_id)  # type: ignore
+                    section_dependencies.add(section_id)  # type: ignore
 
             if QuestionnaireSchema.has_operator(rule):
-                rules_section_dependencies.update(
-                    self._get_rules_section_dependencies(current_section_id, rule)
+                (
+                    nested_section_dependencies,
+                    nested_section_dependencies_for_progress_value_source,
+                    nested_block_dependencies_for_progress_value_source,
+                ) = self._get_rules_section_dependencies(current_section_id, rule)
+                section_dependencies.update(nested_section_dependencies)
+                section_dependencies_for_progress_value_source |= (
+                    nested_section_dependencies_for_progress_value_source
+                )
+                block_dependencies_for_progress_value_source |= (
+                    nested_block_dependencies_for_progress_value_source
                 )
 
-        return rules_section_dependencies
+        return (
+            section_dependencies,
+            section_dependencies_for_progress_value_source,
+            block_dependencies_for_progress_value_source,
+        )
 
     def _populate_calculated_summary_section_dependencies(self) -> None:
         for section in self.get_sections():