From 51c7c574372fc1118c694be17e5da68ab2c42184 Mon Sep 17 00:00:00 2001
From: Jessica McInchak <jessica.mcinchak@gmail.com>
Date: Sun, 17 Nov 2024 11:49:49 +0100
Subject: [PATCH 1/9] editor table is selectable

---
 .../components/PlanningConstraints/Editor.tsx | 45 ++++++++++++++++---
 .../components/PlanningConstraints/model.ts   |  2 +
 2 files changed, 42 insertions(+), 5 deletions(-)

diff --git a/editor.planx.uk/src/@planx/components/PlanningConstraints/Editor.tsx b/editor.planx.uk/src/@planx/components/PlanningConstraints/Editor.tsx
index 0e084932ed..6f1215cdfe 100644
--- a/editor.planx.uk/src/@planx/components/PlanningConstraints/Editor.tsx
+++ b/editor.planx.uk/src/@planx/components/PlanningConstraints/Editor.tsx
@@ -10,7 +10,7 @@ import Typography from "@mui/material/Typography";
 import { ComponentType as TYPES } from "@opensystemslab/planx-core/types";
 import { EditorProps } from "@planx/components/shared/types";
 import { useFormik } from "formik";
-import React from "react";
+import React, { ChangeEvent } from "react";
 import { FONT_WEIGHT_BOLD } from "theme";
 import InputGroup from "ui/editor/InputGroup";
 import { ModalFooter } from "ui/editor/ModalFooter";
@@ -36,8 +36,38 @@ function PlanningConstraintsComponent(props: Props) {
         data: newValues,
       });
     },
+    validate: () => {
+      // TODO must select at least one formik.values.dataValues
+    },
   });
 
+  const changeSelectAll =
+    (vals: string[] | undefined) =>
+    (_event: ChangeEvent<HTMLInputElement>, _checked: boolean) => {
+      let newCheckedVals: string[];
+      if (vals?.length !== availableDatasets.length) {
+        newCheckedVals = availableDatasets.map((d) => d.val);
+      } else {
+        newCheckedVals = [];
+      }
+
+      formik.setFieldValue("dataValues", newCheckedVals);
+    };
+
+  const changeDataset =
+    (val: string) =>
+    (_event: ChangeEvent<HTMLInputElement>, _checked: boolean) => {
+      let newCheckedVals;
+      if (formik.values.dataValues?.includes(val)) {
+        newCheckedVals = formik.values.dataValues.filter((dv) => dv !== val);
+      } else {
+        newCheckedVals = formik.values.dataValues
+          ? [...formik.values.dataValues, val]
+          : [val];
+      }
+      formik.setFieldValue("dataValues", newCheckedVals);
+    };
+
   return (
     <form onSubmit={formik.handleSubmit} id="modal">
       <ModalSection>
@@ -91,8 +121,11 @@ function PlanningConstraintsComponent(props: Props) {
                     <TableCell>
                       <Checkbox
                         color="primary"
-                        checked={true}
-                        disabled={true}
+                        checked={
+                          availableDatasets.length ===
+                          formik.values.dataValues?.length
+                        }
+                        onChange={changeSelectAll(formik.values.dataValues)}
                         inputProps={{
                           "aria-label": "select all constraints",
                         }}
@@ -111,8 +144,10 @@ function PlanningConstraintsComponent(props: Props) {
                         <TableCell sx={{ verticalAlign: "top" }}>
                           <Checkbox
                             color="primary"
-                            checked={true}
-                            disabled={true}
+                            checked={formik.values.dataValues?.includes(
+                              dataset.val,
+                            )}
+                            onChange={changeDataset(dataset.val)}
                           />
                         </TableCell>
                         <TableCell>
diff --git a/editor.planx.uk/src/@planx/components/PlanningConstraints/model.ts b/editor.planx.uk/src/@planx/components/PlanningConstraints/model.ts
index 820491ea7c..63f3683465 100644
--- a/editor.planx.uk/src/@planx/components/PlanningConstraints/model.ts
+++ b/editor.planx.uk/src/@planx/components/PlanningConstraints/model.ts
@@ -5,6 +5,7 @@ export interface PlanningConstraints extends BaseNodeData {
   description: string;
   fn: string;
   disclaimer: string;
+  dataValues?: string[] | undefined;
 }
 
 export const parseContent = (
@@ -16,6 +17,7 @@ export const parseContent = (
     "Planning constraints might limit how you can develop or use the property",
   fn: data?.fn || DEFAULT_FN,
   disclaimer: data?.disclaimer || DEFAULT_PLANNING_CONDITIONS_DISCLAIMER,
+  dataValues: data?.dataValues || availableDatasets.map((d) => d.val),
   ...parseBaseNodeData(data),
 });
 

From ec1c4517644e274267c443e491e7c82b1cd1b112 Mon Sep 17 00:00:00 2001
From: Jessica McInchak <jessica.mcinchak@gmail.com>
Date: Wed, 20 Nov 2024 11:51:21 +0100
Subject: [PATCH 2/9] only kick off frontend GIS requests for selected datasets

---
 .../components/PlanningConstraints/Public.tsx | 55 ++++++++++---------
 1 file changed, 29 insertions(+), 26 deletions(-)

diff --git a/editor.planx.uk/src/@planx/components/PlanningConstraints/Public.tsx b/editor.planx.uk/src/@planx/components/PlanningConstraints/Public.tsx
index 04e345a948..bd855f6f8a 100644
--- a/editor.planx.uk/src/@planx/components/PlanningConstraints/Public.tsx
+++ b/editor.planx.uk/src/@planx/components/PlanningConstraints/Public.tsx
@@ -16,6 +16,7 @@ import { stringify } from "wkt";
 import { SiteAddress } from "../FindProperty/model";
 import { ErrorSummaryContainer } from "../shared/Preview/ErrorSummaryContainer";
 import {
+  availableDatasets,
   type IntersectingConstraints,
   type PlanningConstraints,
 } from "./model";
@@ -36,6 +37,9 @@ export type InaccurateConstraints =
 export default Component;
 
 function Component(props: Props) {
+  // Existing components will not have dataValues prop so should default to all available datasets
+  const dataValues = props.dataValues || availableDatasets.map((d) => d.val);
+
   const [
     currentCardId,
     cachedBreadcrumbs,
@@ -56,8 +60,7 @@ function Component(props: Props) {
 
   // PlanningConstraints must come after at least a FindProperty in the graph
   const showGraphError = !longitude || !latitude;
-  if (showGraphError)
-    throw new GraphError("mapInputFieldMustFollowFindProperty");
+  if (showGraphError) throw new GraphError("nodeMustFollowFindProperty");
 
   // Even though this component will fetch fresh GIS data when coming "back",
   //   still prepopulate any previously marked inaccurateConstraints
@@ -71,79 +74,79 @@ function Component(props: Props) {
   const urlSearchParams = new URLSearchParams(window.location.search);
   const params = Object.fromEntries(urlSearchParams.entries());
 
+  const fetcher: Fetcher<GISResponse> = (url: string) =>
+    fetch(url).then((r) => r.json());
+
   // Get the WKT representation of the site boundary drawing or address point to pass to Planning Data
   const wktPoint = `POINT(${longitude} ${latitude})`;
   const wktPolygon: string | undefined =
     siteBoundary && stringify(siteBoundary);
-
   const planningDataParams: Record<string, string> = {
     geom: wktPolygon || wktPoint,
     ...params,
   };
 
-  // Fetch planning constraints data for a given local authority
-  const root = `${import.meta.env.VITE_APP_API_URL}/gis/${teamSlug}?`;
+  // Fetch planning constraints data for a given local authority if Planning Data & a geometry is available
+  const shouldFetchPlanningData =
+    hasPlanningData &&
+    latitude &&
+    longitude &&
+    dataValues.some((val) => val !== "road.classified");
   const teamGisEndpoint: string =
-    root +
-    new URLSearchParams(
-      hasPlanningData ? planningDataParams : undefined,
-    ).toString();
-
-  const fetcher: Fetcher<GISResponse | GISResponse["constraints"]> = (
-    url: string,
-  ) => fetch(url).then((r) => r.json());
+    `${import.meta.env.VITE_APP_API_URL}/gis/${teamSlug}?` +
+    new URLSearchParams(planningDataParams).toString();
   const {
     data,
     mutate,
     error: dataError,
     isValidating,
-  } = useSWR(() => (latitude && longitude ? teamGisEndpoint : null), fetcher, {
-    revalidateOnFocus: false,
-  });
+  } = useSWR(
+    () => (shouldFetchPlanningData ? teamGisEndpoint : null),
+    fetcher,
+    { revalidateOnFocus: false },
+  );
 
   // If an OS address was selected, additionally fetch classified roads (available nationally) using the USRN identifier,
   //   skip if the applicant plotted a new non-UPRN address on the map
+  const shouldFetchRoads =
+    hasPlanningData && usrn && dataValues.includes("road.classified");
   const classifiedRoadsEndpoint: string =
     `${import.meta.env.VITE_APP_API_URL}/roads?` +
     new URLSearchParams(usrn ? { usrn } : undefined)?.toString();
-
   const {
     data: roads,
     error: roadsError,
     isValidating: isValidatingRoads,
   } = useSWR(
-    () => (usrn && hasPlanningData ? classifiedRoadsEndpoint : null),
+    () => (shouldFetchRoads ? classifiedRoadsEndpoint : null),
     fetcher,
     { revalidateOnFocus: false },
   );
 
   // Merge Planning Data and Roads responses for a unified list of constraints
-  const constraints: GISResponse["constraints"] | Record<string, any> = {
+  const constraints: GISResponse["constraints"] = {
     ...data?.constraints,
     ...roads?.constraints,
   };
-
-  const metadata: GISResponse["metadata"] | Record<string, any> = {
+  const metadata: GISResponse["metadata"] = {
     ...data?.metadata,
     ...roads?.metadata,
   };
 
   const handleSubmit = () => {
     // `_constraints` & `_overrides` are responsible for auditing
-    const _constraints: Array<
-      EnhancedGISResponse | GISResponse["constraints"]
-    > = [];
+    const _constraints: Array<EnhancedGISResponse> = [];
     if (hasPlanningData) {
       if (data && !dataError)
         _constraints.push({
           ...data,
           planxRequest: teamGisEndpoint,
-        } as EnhancedGISResponse);
+        });
       if (roads && !roadsError)
         _constraints.push({
           ...roads,
           planxRequest: classifiedRoadsEndpoint,
-        } as EnhancedGISResponse);
+        });
     }
 
     const hasInaccurateConstraints =

From 65e699ec6c826172ac781b59deb0d816b8f97d3f Mon Sep 17 00:00:00 2001
From: Jessica McInchak <jessica.mcinchak@gmail.com>
Date: Mon, 25 Nov 2024 15:50:38 +0100
Subject: [PATCH 3/9] editor validation plus api gis query params

---
 .../modules/gis/service/digitalLand.ts        |  34 +++-
 .../components/PlanningConstraints/Editor.tsx | 166 +++++++++---------
 .../components/PlanningConstraints/Public.tsx |   1 +
 3 files changed, 112 insertions(+), 89 deletions(-)

diff --git a/api.planx.uk/modules/gis/service/digitalLand.ts b/api.planx.uk/modules/gis/service/digitalLand.ts
index d96115c4c4..f1a715d143 100644
--- a/api.planx.uk/modules/gis/service/digitalLand.ts
+++ b/api.planx.uk/modules/gis/service/digitalLand.ts
@@ -71,15 +71,30 @@ async function go(
   geom: string,
   extras: Record<string, string>,
 ): Promise<GISResponse> {
-  // generate list of digital land datasets we should query based on 'active' planx schema variables
+  // generate list of digital land datasets we should query and their associated passport values
   const activeDatasets: string[] = [];
-  Object.keys(baseSchema).forEach((key) => {
-    if (baseSchema[key]["active"]) {
-      baseSchema[key]["digital-land-datasets"]?.forEach((dataset: string) => {
-        activeDatasets.push(dataset);
-      });
-    }
-  });
+  let activeDataValues: string[] = [];
+  if (extras?.vals) {
+    // if the editor selected constraints, prioritise their selection
+    activeDataValues = extras.vals.split(",");
+    Object.keys(baseSchema).forEach((key) => {
+      if (activeDataValues.includes(key)) {
+        baseSchema[key]["digital-land-datasets"]?.forEach((dataset: string) => {
+          activeDatasets.push(dataset);
+        });
+      }
+    });
+  } else {
+    // else default to the internally maintained list of all "active" datasets
+    Object.keys(baseSchema).forEach((key) => {
+      if (baseSchema[key]["active"]) {
+        activeDataValues.push(key);
+        baseSchema[key]["digital-land-datasets"]?.forEach((dataset: string) => {
+          activeDatasets.push(dataset);
+        });
+      }
+    });
+  }
 
   // set up request query params per https://www.planning.data.gov.uk/docs
   const options = {
@@ -159,7 +174,8 @@ async function go(
   // TODO followup with digital land about how to return 'nots' via API (currently assumes any "active" metadata was successfully queried)
   const nots = Object.keys(baseSchema).filter(
     (key) =>
-      baseSchema[key]["active"] && !Object.keys(formattedResult).includes(key),
+      activeDataValues.includes(key) &&
+      !Object.keys(formattedResult).includes(key),
   );
   nots.forEach((not) => {
     formattedResult[not] = {
diff --git a/editor.planx.uk/src/@planx/components/PlanningConstraints/Editor.tsx b/editor.planx.uk/src/@planx/components/PlanningConstraints/Editor.tsx
index 6f1215cdfe..3ba28fa76b 100644
--- a/editor.planx.uk/src/@planx/components/PlanningConstraints/Editor.tsx
+++ b/editor.planx.uk/src/@planx/components/PlanningConstraints/Editor.tsx
@@ -9,7 +9,7 @@ import TableRow from "@mui/material/TableRow";
 import Typography from "@mui/material/Typography";
 import { ComponentType as TYPES } from "@opensystemslab/planx-core/types";
 import { EditorProps } from "@planx/components/shared/types";
-import { useFormik } from "formik";
+import { FormikErrors, useFormik } from "formik";
 import React, { ChangeEvent } from "react";
 import { FONT_WEIGHT_BOLD } from "theme";
 import InputGroup from "ui/editor/InputGroup";
@@ -17,6 +17,7 @@ import { ModalFooter } from "ui/editor/ModalFooter";
 import ModalSection from "ui/editor/ModalSection";
 import ModalSectionContent from "ui/editor/ModalSectionContent";
 import RichTextInput from "ui/editor/RichTextInput/RichTextInput";
+import ErrorWrapper from "ui/shared/ErrorWrapper";
 import Input from "ui/shared/Input/Input";
 import InputRow from "ui/shared/InputRow";
 
@@ -36,8 +37,12 @@ function PlanningConstraintsComponent(props: Props) {
         data: newValues,
       });
     },
-    validate: () => {
-      // TODO must select at least one formik.values.dataValues
+    validate: (values) => {
+      const errors: FormikErrors<PlanningConstraints> = {};
+      if (!values.dataValues || values.dataValues?.length < 1) {
+        errors.dataValues = "Select at least one constraint";
+      }
+      return errors;
     },
   });
 
@@ -50,7 +55,6 @@ function PlanningConstraintsComponent(props: Props) {
       } else {
         newCheckedVals = [];
       }
-
       formik.setFieldValue("dataValues", newCheckedVals);
     };
 
@@ -114,82 +118,84 @@ function PlanningConstraintsComponent(props: Props) {
             </InputRow>
           </InputGroup>
           <InputGroup label="Which constraints do you want to check?">
-            <TableContainer>
-              <Table size="small">
-                <TableHead>
-                  <TableRow>
-                    <TableCell>
-                      <Checkbox
-                        color="primary"
-                        checked={
-                          availableDatasets.length ===
-                          formik.values.dataValues?.length
-                        }
-                        onChange={changeSelectAll(formik.values.dataValues)}
-                        inputProps={{
-                          "aria-label": "select all constraints",
-                        }}
-                      />
-                    </TableCell>
-                    <TableCell sx={{ fontWeight: FONT_WEIGHT_BOLD }}>
-                      Constraints
-                    </TableCell>
-                  </TableRow>
-                </TableHead>
-                <TableBody>
-                  {availableDatasets
-                    .sort((a, b) => a.val.localeCompare(b.val))
-                    .map((dataset, i: number) => (
-                      <TableRow key={i}>
-                        <TableCell sx={{ verticalAlign: "top" }}>
-                          <Checkbox
-                            color="primary"
-                            checked={formik.values.dataValues?.includes(
-                              dataset.val,
-                            )}
-                            onChange={changeDataset(dataset.val)}
-                          />
-                        </TableCell>
-                        <TableCell>
-                          <InputGroup>
-                            <InputRow>
-                              <Input
-                                format="large"
-                                name="text"
-                                value={dataset.text}
-                                disabled
-                              />
-                            </InputRow>
-                            <InputRow>
-                              <Input
-                                format="data"
-                                name="val"
-                                value={dataset.val}
-                                disabled
-                              />
-                            </InputRow>
-                          </InputGroup>
-                          <Box>
-                            <Typography
-                              variant="body2"
-                              color="GrayText"
-                              sx={{ fontSize: ".8em", pb: 1 }}
-                            >
-                              {`via ${dataset.source}: ${dataset.datasets
-                                .filter(Boolean)
-                                .join(", ")} ${
-                                dataset?.entity
-                                  ? `(entity ${dataset.entity})`
-                                  : ``
-                              }`}
-                            </Typography>
-                          </Box>
-                        </TableCell>
-                      </TableRow>
-                    ))}
-                </TableBody>
-              </Table>
-            </TableContainer>
+            <ErrorWrapper error={formik.errors.dataValues}>
+              <TableContainer>
+                <Table size="small">
+                  <TableHead>
+                    <TableRow>
+                      <TableCell>
+                        <Checkbox
+                          color="primary"
+                          checked={
+                            availableDatasets.length ===
+                            formik.values.dataValues?.length
+                          }
+                          onChange={changeSelectAll(formik.values.dataValues)}
+                          inputProps={{
+                            "aria-label": "select all constraints",
+                          }}
+                        />
+                      </TableCell>
+                      <TableCell sx={{ fontWeight: FONT_WEIGHT_BOLD }}>
+                        Constraints
+                      </TableCell>
+                    </TableRow>
+                  </TableHead>
+                  <TableBody>
+                    {availableDatasets
+                      .sort((a, b) => a.val.localeCompare(b.val))
+                      .map((dataset, i: number) => (
+                        <TableRow key={i}>
+                          <TableCell sx={{ verticalAlign: "top" }}>
+                            <Checkbox
+                              color="primary"
+                              checked={formik.values.dataValues?.includes(
+                                dataset.val,
+                              )}
+                              onChange={changeDataset(dataset.val)}
+                            />
+                          </TableCell>
+                          <TableCell>
+                            <InputGroup>
+                              <InputRow>
+                                <Input
+                                  format="large"
+                                  name="text"
+                                  value={dataset.text}
+                                  disabled
+                                />
+                              </InputRow>
+                              <InputRow>
+                                <Input
+                                  format="data"
+                                  name="val"
+                                  value={dataset.val}
+                                  disabled
+                                />
+                              </InputRow>
+                            </InputGroup>
+                            <Box>
+                              <Typography
+                                variant="body2"
+                                color="GrayText"
+                                sx={{ fontSize: ".8em", pb: 1 }}
+                              >
+                                {`via ${dataset.source}: ${dataset.datasets
+                                  .filter(Boolean)
+                                  .join(", ")} ${
+                                  dataset?.entity
+                                    ? `(entity ${dataset.entity})`
+                                    : ``
+                                }`}
+                              </Typography>
+                            </Box>
+                          </TableCell>
+                        </TableRow>
+                      ))}
+                  </TableBody>
+                </Table>
+              </TableContainer>
+            </ErrorWrapper>
           </InputGroup>
           <InputGroup label="Planning conditions disclaimer">
             <InputRow>
diff --git a/editor.planx.uk/src/@planx/components/PlanningConstraints/Public.tsx b/editor.planx.uk/src/@planx/components/PlanningConstraints/Public.tsx
index bd855f6f8a..209cd1e93c 100644
--- a/editor.planx.uk/src/@planx/components/PlanningConstraints/Public.tsx
+++ b/editor.planx.uk/src/@planx/components/PlanningConstraints/Public.tsx
@@ -83,6 +83,7 @@ function Component(props: Props) {
     siteBoundary && stringify(siteBoundary);
   const planningDataParams: Record<string, string> = {
     geom: wktPolygon || wktPoint,
+    vals: dataValues.join(","),
     ...params,
   };
 

From c63941f63fffbac8887f3bd2fc05acaf8433033b Mon Sep 17 00:00:00 2001
From: Jessica McInchak <jessica.mcinchak@gmail.com>
Date: Thu, 28 Nov 2024 17:29:52 +0100
Subject: [PATCH 4/9] add editor tests

---
 .../PlanningConstraints/Public.test.tsx       | 81 +++++++++++++++++++
 1 file changed, 81 insertions(+)

diff --git a/editor.planx.uk/src/@planx/components/PlanningConstraints/Public.test.tsx b/editor.planx.uk/src/@planx/components/PlanningConstraints/Public.test.tsx
index 8646fbd0de..431d701fe3 100644
--- a/editor.planx.uk/src/@planx/components/PlanningConstraints/Public.test.tsx
+++ b/editor.planx.uk/src/@planx/components/PlanningConstraints/Public.test.tsx
@@ -16,6 +16,7 @@ import {
   simpleBreadcrumbs,
   simpleFlow,
 } from "./mocks/simpleFlow";
+import { availableDatasets } from "./model";
 import PlanningConstraints from "./Public";
 
 const { setState } = useStore;
@@ -259,6 +260,86 @@ describe("following a FindProperty component", () => {
   });
 });
 
+describe("selectable datasets in editor", () => {
+  beforeEach(() => {
+    act(() =>
+      setState({
+        breadcrumbs: simpleBreadcrumbs,
+        flow: simpleFlow,
+        teamIntegrations: {
+          hasPlanningData: true,
+        },
+      }),
+    );
+  });
+
+  it("does not initiate `/roads` request when `road.classified` is not selected by an editor", async () => {
+    setup(
+      <PlanningConstraints
+        title="Planning constraints"
+        description="Things that might affect your project"
+        fn="property.constraints.planning"
+        disclaimer="This page does not include information about historic planning conditions that may apply to this property."
+        handleSubmit={vi.fn()}
+        dataValues={availableDatasets
+          .filter((d) => d.val !== "road.classified")
+          .map((d) => d.val)}
+      />,
+    );
+
+    expect(swr).toHaveBeenCalled();
+
+    // Planning constraints API still called
+    const planingConstraintsURL = (
+      vi.mocked(useSWR).mock.calls[0][0] as () => {}
+    )();
+    const planingConstraintsResponse = vi.mocked(useSWR).mock.results[0].value;
+
+    expect(planingConstraintsURL).toContain("/gis");
+    expect(planingConstraintsResponse).toEqual({
+      data: digitalLandResponseMock,
+    });
+
+    // Roads API not called due to missing `road.classified` data value
+    const roadsURL = (vi.mocked(useSWR).mock.calls[1][0] as () => {})();
+    const roadsResponse = vi.mocked(useSWR).mock.results[1].value;
+
+    expect(roadsURL).toBeNull();
+    expect(roadsResponse).toEqual({ data: null });
+  });
+
+  it("does not initiate `/gis/:localAuthority` request when only `road.classified` is selected by an editor", async () => {
+    setup(
+      <PlanningConstraints
+        title="Planning constraints"
+        description="Things that might affect your project"
+        fn="property.constraints.planning"
+        disclaimer="This page does not include information about historic planning conditions that may apply to this property."
+        handleSubmit={vi.fn()}
+        dataValues={["road.classified"]}
+      />,
+    );
+
+    expect(swr).toHaveBeenCalled();
+
+    // Roads API is called
+    const roadsURL = (vi.mocked(useSWR).mock.calls[1][0] as () => {})();
+    const roadsResponse = vi.mocked(useSWR).mock.results[1].value;
+
+    expect(roadsURL).toContain("/roads");
+    expect(roadsResponse).toEqual({ data: classifiedRoadsResponseMock });
+
+    // Planning constraints API not called due to missing data values
+    const planingConstraintsURL = (
+      vi.mocked(useSWR).mock.calls[0][0] as () => {}
+    )();
+    const planningConstraintsResponse = vi.mocked(useSWR).mock.results[0].value;
+
+    expect(planingConstraintsURL).toBeNull();
+    expect(planningConstraintsResponse).toEqual({ data: null });
+  });
+});
+
 describe("demo state", () => {
   beforeEach(() => {
     act(() =>

From edcfd70b55abf0e8b3e2b3afd4fbf50477f245bf Mon Sep 17 00:00:00 2001
From: Jessica McInchak <jessica.mcinchak@gmail.com>
Date: Thu, 28 Nov 2024 18:08:12 +0100
Subject: [PATCH 5/9] add exactly one planning constraints rule to publish
 validation checks

---
 .../modules/flows/validate/service/index.ts   |  12 +-
 .../validate/service/planningConstraints.ts   |  38 ++++
 .../modules/flows/validate/validate.test.ts   | 185 ++++++++++++++++++
 3 files changed, 233 insertions(+), 2 deletions(-)
 create mode 100644 api.planx.uk/modules/flows/validate/service/planningConstraints.ts

diff --git a/api.planx.uk/modules/flows/validate/service/index.ts b/api.planx.uk/modules/flows/validate/service/index.ts
index 85710b307c..7b77f595e7 100644
--- a/api.planx.uk/modules/flows/validate/service/index.ts
+++ b/api.planx.uk/modules/flows/validate/service/index.ts
@@ -8,8 +8,9 @@ import * as jsondiffpatch from "jsondiffpatch";
 import { dataMerged, getMostRecentPublishedFlow } from "../../../../helpers.js";
 import { validateFileTypes } from "./fileTypes.js";
 import { validateInviteToPay } from "./inviteToPay.js";
-import { validateSections } from "./sections.js";
+import { validatePlanningConstraints } from "./planningConstraints.js";
 import { validateProjectTypes } from "./projectTypes.js";
+import { validateSections } from "./sections.js";
 
 type AlteredNode = {
   id: string;
@@ -54,7 +55,14 @@ const validateAndDiffFlow = async (
   const inviteToPay = validateInviteToPay(flattenedFlow);
   const fileTypes = validateFileTypes(flattenedFlow);
   const projectTypes = validateProjectTypes(flattenedFlow);
-  validationChecks.push(sections, inviteToPay, fileTypes, projectTypes);
+  const planningConstraints = validatePlanningConstraints(flattenedFlow);
+  validationChecks.push(
+    sections,
+    inviteToPay,
+    fileTypes,
+    projectTypes,
+    planningConstraints,
+  );
 
   // Arrange list of validation checks in order of status: Fail, Warn, Pass, Not applicable
   const failingChecks = validationChecks.filter((v) => v.status == "Fail");
diff --git a/api.planx.uk/modules/flows/validate/service/planningConstraints.ts b/api.planx.uk/modules/flows/validate/service/planningConstraints.ts
new file mode 100644
index 0000000000..e86f073349
--- /dev/null
+++ b/api.planx.uk/modules/flows/validate/service/planningConstraints.ts
@@ -0,0 +1,38 @@
+import {
+  ComponentType,
+  type FlowGraph,
+} from "@opensystemslab/planx-core/types";
+import { numberOfComponentType } from "../helpers.js";
+import type { FlowValidationResponse } from "./index.js";
+
+const validatePlanningConstraints = (
+  flowGraph: FlowGraph,
+): FlowValidationResponse => {
+  const numberOfPlanningConstraintNodes = numberOfComponentType(
+    flowGraph,
+    ComponentType.PlanningConstraints,
+  );
+  if (numberOfPlanningConstraintNodes > 1) {
+    return {
+      title: "Planning Constraints",
+      status: "Fail",
+      message:
+        "When using Planning Constraints, your flow must have exactly ONE Planning Constraints component",
+    };
+  } else if (numberOfPlanningConstraintNodes === 1) {
+    // In future, add extra `hasPlanningData` validation step here to ensure integration is available for this team
+    return {
+      title: "Planning Constraints",
+      status: "Pass",
+      message: "Your flow has valid Planning Constraints",
+    };
+  } else {
+    return {
+      title: "Planning Constraints",
+      status: "Not applicable",
+      message: "Your flow is not using Planning Constraints",
+    };
+  }
+};
+
+export { validatePlanningConstraints };
diff --git a/api.planx.uk/modules/flows/validate/validate.test.ts b/api.planx.uk/modules/flows/validate/validate.test.ts
index 46aa4a0833..9850036cd1 100644
--- a/api.planx.uk/modules/flows/validate/validate.test.ts
+++ b/api.planx.uk/modules/flows/validate/validate.test.ts
@@ -131,6 +131,11 @@ describe("sections validation on diff", () => {
             message:
               'Your flow is not using Checklists which set "proposal.projectType"',
           },
+          {
+            title: "Planning Constraints",
+            status: "Not applicable",
+            message: "Your flow is not using Planning Constraints",
+          },
         ]);
       });
   });
@@ -190,6 +195,11 @@ describe("sections validation on diff", () => {
             message:
               'Your flow is not using Checklists which set "proposal.projectType"',
           },
+          {
+            title: "Planning Constraints",
+            status: "Not applicable",
+            message: "Your flow is not using Planning Constraints",
+          },
         ]);
       });
   });
@@ -240,6 +250,11 @@ describe("invite to pay validation on diff", () => {
             status: "Not applicable",
             message: "Your flow is not using FileUpload or UploadAndLabel",
           },
+          {
+            title: "Planning Constraints",
+            status: "Not applicable",
+            message: "Your flow is not using Planning Constraints",
+          },
         ]);
       });
   });
@@ -300,6 +315,11 @@ describe("invite to pay validation on diff", () => {
             status: "Not applicable",
             message: "Your flow is not using FileUpload or UploadAndLabel",
           },
+          {
+            title: "Planning Constraints",
+            status: "Not applicable",
+            message: "Your flow is not using Planning Constraints",
+          },
         ]);
       });
   });
@@ -356,6 +376,11 @@ describe("invite to pay validation on diff", () => {
             status: "Not applicable",
             message: "Your flow is not using FileUpload or UploadAndLabel",
           },
+          {
+            title: "Planning Constraints",
+            status: "Not applicable",
+            message: "Your flow is not using Planning Constraints",
+          },
         ]);
       });
   });
@@ -414,6 +439,11 @@ describe("invite to pay validation on diff", () => {
             status: "Not applicable",
             message: "Your flow is not using FileUpload or UploadAndLabel",
           },
+          {
+            title: "Planning Constraints",
+            status: "Not applicable",
+            message: "Your flow is not using Planning Constraints",
+          },
         ]);
       });
   });
@@ -468,6 +498,11 @@ describe("invite to pay validation on diff", () => {
             message:
               'Your flow is not using Checklists which set "proposal.projectType"',
           },
+          {
+            title: "Planning Constraints",
+            status: "Not applicable",
+            message: "Your flow is not using Planning Constraints",
+          },
         ]);
       });
   });
@@ -555,6 +590,11 @@ describe("ODP Schema file type validation on diff", () => {
             message:
               'Your flow is not using Checklists which set "proposal.projectType"',
           },
+          {
+            title: "Planning Constraints",
+            status: "Not applicable",
+            message: "Your flow is not using Planning Constraints",
+          },
         ]);
       });
   });
@@ -633,6 +673,151 @@ describe("ODP Schema file type validation on diff", () => {
             message:
               'Your flow is not using Checklists which set "proposal.projectType"',
           },
+          {
+            title: "Planning Constraints",
+            status: "Not applicable",
+            message: "Your flow is not using Planning Constraints",
+          },
+        ]);
+      });
+  });
+});
+
+describe("planning constraints validation on diff", () => {
+  it("passes if there is exactly one planning constraints component", async () => {
+    const alteredFlow = {
+      ...mockFlowData,
+      PlanningConstraints: {
+        type: 11,
+        data: {
+          title: "Check all constraints",
+          fn: "property.constraints.planning",
+        },
+      },
+    };
+
+    queryMock.mockQuery({
+      name: "GetFlowData",
+      matchOnVariables: false,
+      data: {
+        flow: {
+          data: alteredFlow,
+          slug: "altered-flow-name",
+          team_id: 1,
+          team: {
+            slug: "testing",
+          },
+          publishedFlows: [{ data: alteredFlow }],
+        },
+      },
+    });
+
+    await supertest(app)
+      .post("/flows/1/diff")
+      .set(auth)
+      .expect(200)
+      .then((res) => {
+        expect(res.body.message).toEqual("Changes queued to publish");
+        expect(res.body.validationChecks).toEqual([
+          {
+            title: "Sections",
+            status: "Pass",
+            message: "Your flow has valid Sections",
+          },
+          {
+            title: "Planning Constraints",
+            status: "Pass",
+            message: "Your flow has valid Planning Constraints",
+          },
+          {
+            title: "Invite to Pay",
+            status: "Not applicable",
+            message: "Your flow is not using Invite to Pay",
+          },
+          {
+            title: "File types",
+            status: "Not applicable",
+            message: "Your flow is not using FileUpload or UploadAndLabel",
+          },
+          {
+            title: "Project types",
+            status: "Not applicable",
+            message:
+              'Your flow is not using Checklists which set "proposal.projectType"',
+          },
+        ]);
+      });
+  });
+
+  it("warns if there is more than one planning constraints component", async () => {
+    const alteredFlow = {
+      ...mockFlowData,
+      PlanningConstraints: {
+        type: 11,
+        data: {
+          title: "Check all constraints",
+          fn: "property.constraints.planning",
+        },
+      },
+      PlanningConstraintsTwo: {
+        type: 11,
+        data: {
+          title: "Check all constraints (dupe)",
+          fn: "property.constraints.planning",
+        },
+      },
+    };
+
+    queryMock.mockQuery({
+      name: "GetFlowData",
+      matchOnVariables: false,
+      data: {
+        flow: {
+          data: alteredFlow,
+          slug: "altered-flow-name",
+          team_id: 1,
+          team: {
+            slug: "testing",
+          },
+          publishedFlows: [{ data: alteredFlow }],
+        },
+      },
+    });
+
+    await supertest(app)
+      .post("/flows/1/diff")
+      .set(auth)
+      .expect(200)
+      .then((res) => {
+        expect(res.body.message).toEqual("Changes queued to publish");
+        expect(res.body.validationChecks).toEqual([
+          {
+            title: "Planning Constraints",
+            status: "Fail",
+            message:
+              "When using Planning Constraints, your flow must have exactly ONE Planning Constraints component",
+          },
+          {
+            title: "Sections",
+            status: "Pass",
+            message: "Your flow has valid Sections",
+          },
+          {
+            title: "Invite to Pay",
+            status: "Not applicable",
+            message: "Your flow is not using Invite to Pay",
+          },
+          {
+            title: "File types",
+            status: "Not applicable",
+            message: "Your flow is not using FileUpload or UploadAndLabel",
+          },
+          {
+            title: "Project types",
+            status: "Not applicable",
+            message:
+              'Your flow is not using Checklists which set "proposal.projectType"',
+          },
         ]);
       });
   });

From 5741b31b7552fca414f993bf3d601897a0894aa4 Mon Sep 17 00:00:00 2001
From: Jessica McInchak <jessica.mcinchak@gmail.com>
Date: Fri, 29 Nov 2024 10:34:06 +0100
Subject: [PATCH 6/9] use validationSchema and update checkboxes

---
 .../components/PlanningConstraints/Editor.tsx | 43 +++++++++----------
 1 file changed, 20 insertions(+), 23 deletions(-)

diff --git a/editor.planx.uk/src/@planx/components/PlanningConstraints/Editor.tsx b/editor.planx.uk/src/@planx/components/PlanningConstraints/Editor.tsx
index 3ba28fa76b..9770ab1bdc 100644
--- a/editor.planx.uk/src/@planx/components/PlanningConstraints/Editor.tsx
+++ b/editor.planx.uk/src/@planx/components/PlanningConstraints/Editor.tsx
@@ -1,5 +1,4 @@
 import Box from "@mui/material/Box";
-import Checkbox from "@mui/material/Checkbox";
 import Table from "@mui/material/Table";
 import TableBody from "@mui/material/TableBody";
 import TableCell from "@mui/material/TableCell";
@@ -9,17 +8,18 @@ import TableRow from "@mui/material/TableRow";
 import Typography from "@mui/material/Typography";
 import { ComponentType as TYPES } from "@opensystemslab/planx-core/types";
 import { EditorProps } from "@planx/components/shared/types";
-import { FormikErrors, useFormik } from "formik";
-import React, { ChangeEvent } from "react";
-import { FONT_WEIGHT_BOLD } from "theme";
+import { useFormik } from "formik";
+import React from "react";
 import InputGroup from "ui/editor/InputGroup";
 import { ModalFooter } from "ui/editor/ModalFooter";
 import ModalSection from "ui/editor/ModalSection";
 import ModalSectionContent from "ui/editor/ModalSectionContent";
 import RichTextInput from "ui/editor/RichTextInput/RichTextInput";
+import Checkbox from "ui/shared/Checkbox/Checkbox";
 import ErrorWrapper from "ui/shared/ErrorWrapper";
 import Input from "ui/shared/Input/Input";
 import InputRow from "ui/shared/InputRow";
+import { array, object, string } from "yup";
 
 import { ICONS } from "../shared/icons";
 import { availableDatasets, parseContent, PlanningConstraints } from "./model";
@@ -37,18 +37,14 @@ function PlanningConstraintsComponent(props: Props) {
         data: newValues,
       });
     },
-    validate: (values) => {
-      const errors: FormikErrors<PlanningConstraints> = {};
-      if (!values.dataValues || values.dataValues?.length < 1) {
-        errors.dataValues = "Select at least one constraint";
-      }
-      return errors;
-    },
+    validationSchema: object({
+      dataValues: array(string()).min(1, "Select at least one constraint"),
+    }),
   });
 
   const changeSelectAll =
     (vals: string[] | undefined) =>
-    (_event: ChangeEvent<HTMLInputElement>, _checked: boolean) => {
+    (_event?: React.MouseEvent<HTMLButtonElement, MouseEvent> | undefined) => {
       let newCheckedVals: string[];
       if (vals?.length !== availableDatasets.length) {
         newCheckedVals = availableDatasets.map((d) => d.val);
@@ -60,7 +56,7 @@ function PlanningConstraintsComponent(props: Props) {
 
   const changeDataset =
     (val: string) =>
-    (_event: ChangeEvent<HTMLInputElement>, _checked: boolean) => {
+    (_event?: React.MouseEvent<HTMLButtonElement, MouseEvent> | undefined) => {
       let newCheckedVals;
       if (formik.values.dataValues?.includes(val)) {
         newCheckedVals = formik.values.dataValues.filter((dv) => dv !== val);
@@ -125,19 +121,18 @@ function PlanningConstraintsComponent(props: Props) {
                     <TableRow>
                       <TableCell>
                         <Checkbox
-                          color="primary"
+                          id={"all-constraints-checkbox"}
                           checked={
                             availableDatasets.length ===
                             formik.values.dataValues?.length
                           }
                           onChange={changeSelectAll(formik.values.dataValues)}
-                          inputProps={{
-                            "aria-label": "select all constraints",
-                          }}
                         />
                       </TableCell>
-                      <TableCell sx={{ fontWeight: FONT_WEIGHT_BOLD }}>
-                        Constraints
+                      <TableCell
+                        sx={{ fontSize: (theme) => theme.typography.h4 }}
+                      >
+                        All constraints
                       </TableCell>
                     </TableRow>
                   </TableHead>
@@ -148,10 +143,12 @@ function PlanningConstraintsComponent(props: Props) {
                         <TableRow key={i}>
                           <TableCell sx={{ verticalAlign: "top" }}>
                             <Checkbox
-                              color="primary"
-                              checked={formik.values.dataValues?.includes(
-                                dataset.val,
-                              )}
+                              id={`${dataset.val}-checkbox`}
+                              checked={
+                                formik.values.dataValues?.includes(
+                                  dataset.val,
+                                ) || false
+                              }
                               onChange={changeDataset(dataset.val)}
                             />
                           </TableCell>

From bb8b36e2fdff25efce556807949df5fbfec6f2a0 Mon Sep 17 00:00:00 2001
From: Jessica McInchak <jessica.mcinchak@gmail.com>
Date: Wed, 4 Dec 2024 23:26:27 +0100
Subject: [PATCH 7/9] working automation?

---
 ...automations.planningConstraintNots.test.ts | 49 ++++++++++++--
 .../src/pages/FlowEditor/lib/store/preview.ts | 67 +++++++++++--------
 2 files changed, 84 insertions(+), 32 deletions(-)

diff --git a/editor.planx.uk/src/pages/FlowEditor/lib/__tests__/automations.planningConstraintNots.test.ts b/editor.planx.uk/src/pages/FlowEditor/lib/__tests__/automations.planningConstraintNots.test.ts
index 0c6fa4217d..5089f95f82 100644
--- a/editor.planx.uk/src/pages/FlowEditor/lib/__tests__/automations.planningConstraintNots.test.ts
+++ b/editor.planx.uk/src/pages/FlowEditor/lib/__tests__/automations.planningConstraintNots.test.ts
@@ -9,7 +9,7 @@ const {
   computePassport,
 } = getState();
 
-describe("Auto-answering using planning constraints `_nots`", () => {
+describe("Auto-answering based on planning constraints", () => {
   beforeEach(() => {
     resetPreview();
     setState({ flow });
@@ -51,9 +51,7 @@ describe("Auto-answering using planning constraints `_nots`", () => {
       "ConservationAreaNo",
     ]);
     expect(autoAnswerableOptions("Article4Question")).toEqual(["Article4Yes"]);
-    expect(autoAnswerableOptions("FloodZone1Question")).toEqual([
-      "FloodZone1No",
-    ]); // Because we have passport vals, follows blank independent of options
+    expect(autoAnswerableOptions("FloodZone1Question")).toBeUndefined(); // Puts to user because unseen option
   });
 
   test("When there are only negative `_nots` constraints", () => {
@@ -92,8 +90,49 @@ describe("Auto-answering using planning constraints `_nots`", () => {
       "ConservationAreaNo",
     ]);
     expect(autoAnswerableOptions("Article4Question")).toEqual(["Article4No"]);
-    expect(autoAnswerableOptions("FloodZone1Question")).toBeUndefined(); // Because we do not have positive passport vals, puts to user because unseen option
+    expect(autoAnswerableOptions("FloodZone1Question")).toBeUndefined(); // Puts to user because unseen option
   });
+
+  test("When there are only positive intersecting constraints", () => {
+    expect(upcomingCardIds()).toEqual([
+      "PlanningConstraints",
+      "ConservationAreaQuestion",
+      "Article4Question",
+      "FloodZone1Question",
+    ]);
+
+    // Manually proceed forward through PlanningConstraints as if we've checked 4x datasets: Article 4, Conservation Area, Flood Zone 2, Flood Zone 3
+    clickContinue("PlanningConstraints", {
+      data: {
+        "property.constraints.planning": [
+          "article4",
+          "designated.conservationArea",
+          // "flood.zone.2",
+          // "flood.zone.3",
+        ],
+      },
+      auto: false,
+    });
+
+    expect(computePassport()?.data).toHaveProperty(
+      "property.constraints.planning",
+    );
+    expect(computePassport()?.data).not.toHaveProperty([
+      "_nots",
+      "property.constraints.planning",
+    ]);
+
+    // Confirm auto-answer behavior
+    expect(autoAnswerableOptions("ConservationAreaQuestion")).toEqual([
+      "ConservationAreaYes",
+    ]);
+    expect(autoAnswerableOptions("Article4Question")).toEqual(["Article4Yes"]);
+    expect(autoAnswerableOptions("FloodZone1Question")).toBeUndefined(); // Puts to user because unseen option
+  });
+
+  test.todo(
+    "An unseen option is put to the user exactly once then auto-answered",
+  );
 });
 
 const flow: Store.Flow = {
diff --git a/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts b/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts
index 8f2f901869..b9b754f72b 100644
--- a/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts
+++ b/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts
@@ -11,6 +11,7 @@ import {
   flatFlags,
 } from "@opensystemslab/planx-core/types";
 import { FileList } from "@planx/components/FileUploadAndLabel/model";
+import { DEFAULT_FN as planningConstraintsFn } from "@planx/components/PlanningConstraints/model";
 import { SetValue } from "@planx/components/SetValue/model";
 import { handleSetValue } from "@planx/components/SetValue/utils";
 import { sortIdsDepthFirst } from "@planx/graph";
@@ -527,7 +528,17 @@ export const previewStore: StateCreator<
     );
     if (!visitedFns.length) return;
 
-    // Get all options (aka edges or Answer nodes) for this node
+    // For each visited node, get the data values of its' options (aka edges or Answer nodes)
+    let visitedOptionVals: string[] = [];
+    visitedFns.forEach(([nodeId, _breadcrumb]) => {
+      flow[nodeId].edges?.map((edgeId) => {
+        if (flow[edgeId].type === TYPES.Answer && flow[edgeId].data?.val) {
+          visitedOptionVals.push(flow[edgeId].data.val);
+        }
+      });
+    });
+
+    // Get all options for the current node
     const options: Array<Store.Node> = edges.map((edgeId) => ({
       id: edgeId,
       ...flow[edgeId],
@@ -541,15 +552,24 @@ export const previewStore: StateCreator<
       )
       // Only keep options with a data value set (remove blanks)
       .filter((option) => option.data?.val);
+    const sortedOptionVals: string[] = sortedOptions.map(
+      (option) => option.data?.val,
+    );
     const blankOption = options.find((option) => !option.data?.val);
     let optionsThatCanBeAutoAnswered: Array<NodeId> = [];
 
     // Get existing passport value(s) for this node's fn
     const passportValues = passport.data?.[data.fn];
 
+    // Planning constraints use a bespoke "_nots" structure to differentiate intersecting & not-intersecting passport values and therefore require special automation rules later
+    const nots: string[] | undefined =
+      passport.data?.["_nots"]?.[planningConstraintsFn];
+
     // If we have existing passport value(s) for this fn in an eligible automation format (eg not numbers or plain strings),
     //   then proceed through the matching option(s) or the blank option independent if other vals have been seen before
-    if (Array.isArray(passportValues) && passportValues.length > 0) {
+    const foundPassportValues =
+      Array.isArray(passportValues) && passportValues.length > 0;
+    if (foundPassportValues) {
       // Check if the existing passport value(s) startsWith at least one option's val (eg passport retains most granular values only)
       const matchingPassportValues = passportValues.filter(
         (passportValue: any) =>
@@ -577,34 +597,27 @@ export const previewStore: StateCreator<
           });
         });
       } else {
-        if (blankOption?.id) optionsThatCanBeAutoAnswered.push(blankOption.id);
-      }
-    } else {
-      // If we don't have any existing passport values for this fn but we do have a blank option,
-      //  proceed through the blank if every option's val has been visited before
-      const sortedOptionVals: string[] = sortedOptions.map(
-        (option) => option.data?.val,
-      );
-      let visitedOptionVals: string[] = [];
-      visitedFns.forEach(([nodeId, _breadcrumb]) => {
-        flow[nodeId].edges?.map((edgeId) => {
-          if (flow[edgeId].type === TYPES.Answer && flow[edgeId].data?.val) {
-            visitedOptionVals.push(flow[edgeId].data.val);
+        // Planning constraints may have foundPassportValues (intersecting constraints only) in addition to nots
+        //   ensure the blank option is only only auto-answered if the not-blank option values are valid constraints that we checked (intersecting or not)
+        if (data.fn === planningConstraintsFn) {
+          if (blankOption?.id && nots) {
+            const seenPlanningConstraintVals =
+              sortedOptionVals.concat(visitedOptionVals);
+            if (seenPlanningConstraintVals.some((val) => nots.includes(val)))
+              optionsThatCanBeAutoAnswered.push(blankOption?.id);
           }
-        });
-      });
+        } else if (blankOption?.id) {
+          optionsThatCanBeAutoAnswered.push(blankOption.id);
+        }
+      }
+    }
 
+    // If we don't have any existing passport values for this fn but we do have a blank option,
+    //  proceed through the blank if every option's val has been visited before
+    if (!foundPassportValues) {
       // Planning Constraints use a bespoke "_nots" data structure to describe all option vals returned via GIS API
       //   Concat these onto other visitedOptionVals so that questions about constraints we haven't fetched are put to user exactly once
-      if (
-        visitedFns.some(
-          ([nodeId, _breadcrumb]) =>
-            flow[nodeId].type === TYPES.PlanningConstraints,
-        )
-      ) {
-        const nots: string[] | undefined = passport.data?.["_nots"]?.[data.fn];
-        if (nots) visitedOptionVals = visitedOptionVals.concat(nots);
-      }
+      if (nots) visitedOptionVals = visitedOptionVals.concat(nots);
 
       const hasVisitedEveryOption = sortedOptionVals.every((value) =>
         visitedOptionVals.includes(value),
@@ -632,7 +645,7 @@ export const previewStore: StateCreator<
     const { breadcrumbs, flow } = get();
 
     const node = flow[filterId];
-    if (!node) return; 
+    if (!node) return;
 
     // Only Filter nodes that have an fn & edges are eligible for auto-answering
     const { type, data, edges } = node;

From 8fdf00f9e89abd51012ec6fe532cebe90f181873 Mon Sep 17 00:00:00 2001
From: Jessica McInchak <jessica.mcinchak@gmail.com>
Date: Thu, 5 Dec 2024 21:46:06 +0100
Subject: [PATCH 8/9] updated logic and tests

---
 .../components/PlanningConstraints/model.ts   |   2 +-
 ...automations.planningConstraintNots.test.ts | 227 ----------
 .../automations.planningConstraints.test.ts   | 411 ++++++++++++++++++
 .../src/pages/FlowEditor/lib/store/preview.ts |  85 ++--
 4 files changed, 466 insertions(+), 259 deletions(-)
 delete mode 100644 editor.planx.uk/src/pages/FlowEditor/lib/__tests__/automations.planningConstraintNots.test.ts
 create mode 100644 editor.planx.uk/src/pages/FlowEditor/lib/__tests__/automations.planningConstraints.test.ts

diff --git a/editor.planx.uk/src/@planx/components/PlanningConstraints/model.ts b/editor.planx.uk/src/@planx/components/PlanningConstraints/model.ts
index 63f3683465..71fded6d87 100644
--- a/editor.planx.uk/src/@planx/components/PlanningConstraints/model.ts
+++ b/editor.planx.uk/src/@planx/components/PlanningConstraints/model.ts
@@ -118,7 +118,7 @@ export const availableDatasets: Dataset[] = [
   },
   {
     text: "Ramsar Sites",
-    val: "nature.ramsar",
+    val: "nature.ramsarSite",
     source: "Planning Data",
     datasets: ["ramsar"],
   },
diff --git a/editor.planx.uk/src/pages/FlowEditor/lib/__tests__/automations.planningConstraintNots.test.ts b/editor.planx.uk/src/pages/FlowEditor/lib/__tests__/automations.planningConstraintNots.test.ts
deleted file mode 100644
index 5089f95f82..0000000000
--- a/editor.planx.uk/src/pages/FlowEditor/lib/__tests__/automations.planningConstraintNots.test.ts
+++ /dev/null
@@ -1,227 +0,0 @@
-import { Store, useStore } from "../store";
-import { clickContinue } from "./utils";
-
-const { getState, setState } = useStore;
-const {
-  upcomingCardIds,
-  resetPreview,
-  autoAnswerableOptions,
-  computePassport,
-} = getState();
-
-describe("Auto-answering based on planning constraints", () => {
-  beforeEach(() => {
-    resetPreview();
-    setState({ flow });
-  });
-
-  test("When there are postive intersecting constraints and `_nots`", () => {
-    expect(upcomingCardIds()).toEqual([
-      "PlanningConstraints",
-      "ConservationAreaQuestion",
-      "Article4Question",
-      "FloodZone1Question",
-    ]);
-
-    // Manually proceed forward through PlanningConstraints as if we've checked 4x datasets: Article 4, Conservation Area, Flood Zone 2, Flood Zone 3
-    clickContinue("PlanningConstraints", {
-      data: {
-        "property.constraints.planning": ["article4"],
-        _nots: {
-          "property.constraints.planning": [
-            "designated.conservationArea",
-            "flood.zone.2",
-            "flood.zone.3",
-          ],
-        },
-      },
-      auto: false,
-    });
-
-    expect(computePassport()?.data).toHaveProperty(
-      "property.constraints.planning",
-    );
-    expect(computePassport()?.data).toHaveProperty([
-      "_nots",
-      "property.constraints.planning",
-    ]);
-
-    // Confirm auto-answer behavior
-    expect(autoAnswerableOptions("ConservationAreaQuestion")).toEqual([
-      "ConservationAreaNo",
-    ]);
-    expect(autoAnswerableOptions("Article4Question")).toEqual(["Article4Yes"]);
-    expect(autoAnswerableOptions("FloodZone1Question")).toBeUndefined(); // Puts to user because unseen option
-  });
-
-  test("When there are only negative `_nots` constraints", () => {
-    expect(upcomingCardIds()).toEqual([
-      "PlanningConstraints",
-      "ConservationAreaQuestion",
-      "Article4Question",
-      "FloodZone1Question",
-    ]);
-
-    // Manually proceed forward through PlanningConstraints as if we've checked 4x datasets: Article 4, Conservation Area, Flood Zone 2, Flood Zone 3
-    clickContinue("PlanningConstraints", {
-      data: {
-        _nots: {
-          "property.constraints.planning": [
-            "article4",
-            "designated.conservationArea",
-            "flood.zone.2",
-            "flood.zone.3",
-          ],
-        },
-      },
-      auto: false,
-    });
-
-    expect(computePassport()?.data).not.toHaveProperty(
-      "property.constraints.planning",
-    );
-    expect(computePassport()?.data).toHaveProperty([
-      "_nots",
-      "property.constraints.planning",
-    ]);
-
-    // Confirm auto-answer behavior
-    expect(autoAnswerableOptions("ConservationAreaQuestion")).toEqual([
-      "ConservationAreaNo",
-    ]);
-    expect(autoAnswerableOptions("Article4Question")).toEqual(["Article4No"]);
-    expect(autoAnswerableOptions("FloodZone1Question")).toBeUndefined(); // Puts to user because unseen option
-  });
-
-  test("When there are only positive intersecting constraints", () => {
-    expect(upcomingCardIds()).toEqual([
-      "PlanningConstraints",
-      "ConservationAreaQuestion",
-      "Article4Question",
-      "FloodZone1Question",
-    ]);
-
-    // Manually proceed forward through PlanningConstraints as if we've checked 4x datasets: Article 4, Conservation Area, Flood Zone 2, Flood Zone 3
-    clickContinue("PlanningConstraints", {
-      data: {
-        "property.constraints.planning": [
-          "article4",
-          "designated.conservationArea",
-          // "flood.zone.2",
-          // "flood.zone.3",
-        ],
-      },
-      auto: false,
-    });
-
-    expect(computePassport()?.data).toHaveProperty(
-      "property.constraints.planning",
-    );
-    expect(computePassport()?.data).not.toHaveProperty([
-      "_nots",
-      "property.constraints.planning",
-    ]);
-
-    // Confirm auto-answer behavior
-    expect(autoAnswerableOptions("ConservationAreaQuestion")).toEqual([
-      "ConservationAreaYes",
-    ]);
-    expect(autoAnswerableOptions("Article4Question")).toEqual(["Article4Yes"]);
-    expect(autoAnswerableOptions("FloodZone1Question")).toBeUndefined(); // Puts to user because unseen option
-  });
-
-  test.todo(
-    "An unseen option is put to the user exactly once then auto-answered",
-  );
-});
-
-const flow: Store.Flow = {
-  _root: {
-    edges: [
-      "PlanningConstraints",
-      "ConservationAreaQuestion",
-      "Article4Question",
-      "FloodZone1Question", // flood.zone.1 is NOT fetched or set by Planning Data
-    ],
-  },
-  PlanningConstraints: {
-    type: 11,
-    data: {
-      title: "Planning constraints",
-      description:
-        "Planning constraints might limit how you can develop or use the property",
-      fn: "property.constraints.planning",
-      disclaimer:
-        "<p><strong>This page does not include information about historic planning conditions that may apply to this property.</strong></p>",
-    },
-  },
-  ConservationAreaQuestion: {
-    type: 100,
-    data: {
-      fn: "property.constraints.planning",
-      text: "Are you in a conservation area?",
-      neverAutoAnswer: false,
-      tags: [],
-    },
-    edges: ["ConservationAreaYes", "ConservationAreaNo"],
-  },
-  ConservationAreaYes: {
-    type: 200,
-    data: {
-      text: "Yes",
-      val: "designated.conservationArea",
-    },
-  },
-  ConservationAreaNo: {
-    type: 200,
-    data: {
-      text: "No",
-    },
-  },
-  Article4Question: {
-    type: 100,
-    data: {
-      fn: "property.constraints.planning",
-      text: "Do any Article 4 directions apply?",
-      neverAutoAnswer: false,
-    },
-    edges: ["Article4Yes", "Article4No"],
-  },
-  Article4Yes: {
-    type: 200,
-    data: {
-      text: "Yes",
-      val: "article4",
-    },
-  },
-  Article4No: {
-    type: 200,
-    data: {
-      text: "No",
-    },
-  },
-  FloodZone1Question: {
-    type: 100,
-    data: {
-      description:
-        "<p>(This dataset is not fetched or set via Planning Data)</p>",
-      fn: "property.constraints.planning",
-      text: "Are you in flood zone 1?",
-      neverAutoAnswer: false,
-    },
-    edges: ["FloodZone1Yes", "FloodZone1No"],
-  },
-  FloodZone1Yes: {
-    type: 200,
-    data: {
-      text: "Yes",
-      val: "flood.zone.1",
-    },
-  },
-  FloodZone1No: {
-    type: 200,
-    data: {
-      text: "No",
-    },
-  },
-};
diff --git a/editor.planx.uk/src/pages/FlowEditor/lib/__tests__/automations.planningConstraints.test.ts b/editor.planx.uk/src/pages/FlowEditor/lib/__tests__/automations.planningConstraints.test.ts
new file mode 100644
index 0000000000..df3261c8a8
--- /dev/null
+++ b/editor.planx.uk/src/pages/FlowEditor/lib/__tests__/automations.planningConstraints.test.ts
@@ -0,0 +1,411 @@
+import { Store, useStore } from "../store";
+import { clickContinue } from "./utils";
+
+const { getState, setState } = useStore;
+const {
+  upcomingCardIds,
+  resetPreview,
+  autoAnswerableOptions,
+  computePassport,
+} = getState();
+
+describe("Auto-answering based on planning constraints", () => {
+  beforeEach(() => {
+    resetPreview();
+    setState({ flow });
+  });
+
+  test("When there are postive intersecting constraints and `_nots`", () => {
+    expect(upcomingCardIds()).toEqual([
+      "PlanningConstraints",
+      "ConservationAreaQuestion",
+      "Article4Question",
+      "FloodZone1Question",
+    ]);
+
+    // Manually proceed forward through PlanningConstraints as if we've checked 4x datasets: Article 4, Conservation Area, Flood Zone 2, Flood Zone 3
+    clickContinue("PlanningConstraints", {
+      data: {
+        "property.constraints.planning": ["article4"],
+        _nots: {
+          "property.constraints.planning": [
+            "designated.conservationArea",
+            "flood.zone.2",
+            "flood.zone.3",
+          ],
+        },
+      },
+      auto: false,
+    });
+
+    expect(computePassport()?.data).toHaveProperty(
+      "property.constraints.planning",
+    );
+    expect(computePassport()?.data).toHaveProperty([
+      "_nots",
+      "property.constraints.planning",
+    ]);
+
+    // Confirm auto-answer behavior
+    expect(autoAnswerableOptions("ConservationAreaQuestion")).toEqual([
+      "ConservationAreaNo",
+    ]);
+    expect(autoAnswerableOptions("Article4Question")).toEqual(["Article4Yes"]);
+    expect(autoAnswerableOptions("FloodZone1Question")).toBeUndefined(); // Puts to user because unseen option
+  });
+
+  test("When there are only negative `_nots` constraints", () => {
+    expect(upcomingCardIds()).toEqual([
+      "PlanningConstraints",
+      "ConservationAreaQuestion",
+      "Article4Question",
+      "FloodZone1Question",
+    ]);
+
+    // Manually proceed forward through PlanningConstraints as if we've checked 4x datasets: Article 4, Conservation Area, Flood Zone 2, Flood Zone 3
+    clickContinue("PlanningConstraints", {
+      data: {
+        _nots: {
+          "property.constraints.planning": [
+            "article4",
+            "designated.conservationArea",
+            "flood.zone.2",
+            "flood.zone.3",
+          ],
+        },
+      },
+      auto: false,
+    });
+
+    expect(computePassport()?.data).not.toHaveProperty(
+      "property.constraints.planning",
+    );
+    expect(computePassport()?.data).toHaveProperty([
+      "_nots",
+      "property.constraints.planning",
+    ]);
+
+    // Confirm auto-answer behavior
+    expect(autoAnswerableOptions("ConservationAreaQuestion")).toEqual([
+      "ConservationAreaNo",
+    ]);
+    expect(autoAnswerableOptions("Article4Question")).toEqual(["Article4No"]);
+    expect(autoAnswerableOptions("FloodZone1Question")).toBeUndefined(); // Puts to user because unseen option
+  });
+
+  test("When there are only positive intersecting constraints", () => {
+    expect(upcomingCardIds()).toEqual([
+      "PlanningConstraints",
+      "ConservationAreaQuestion",
+      "Article4Question",
+      "FloodZone1Question",
+    ]);
+
+    // Manually proceed forward through PlanningConstraints as if we've checked 4x datasets: Article 4, Conservation Area, Flood Zone 2, Flood Zone 3
+    clickContinue("PlanningConstraints", {
+      data: {
+        "property.constraints.planning": [
+          "article4",
+          "designated.conservationArea",
+          "flood.zone.2",
+          "flood.zone.3",
+        ],
+      },
+      auto: false,
+    });
+
+    expect(computePassport()?.data).toHaveProperty(
+      "property.constraints.planning",
+    );
+    expect(computePassport()?.data).not.toHaveProperty([
+      "_nots",
+      "property.constraints.planning",
+    ]);
+
+    // Confirm auto-answer behavior
+    expect(autoAnswerableOptions("ConservationAreaQuestion")).toEqual([
+      "ConservationAreaYes",
+    ]);
+    expect(autoAnswerableOptions("Article4Question")).toEqual(["Article4Yes"]);
+    expect(autoAnswerableOptions("FloodZone1Question")).toBeUndefined(); // Puts to user because unseen option
+  });
+
+  test("An unseen option is put to the user exactly once then auto-answered", () => {
+    const alteredFlow = {
+      ...flow,
+      _root: {
+        edges: [
+          "PlanningConstraints",
+          "ConservationAreaQuestion",
+          "Article4Question",
+          "FloodZone1Question", // flood.zone.1 is NOT fetched or set by Planning Data
+          "FloodZone1QuestionAgain",
+        ],
+      },
+      FloodZone1QuestionAgain: {
+        type: 100,
+        data: {
+          description:
+            "<p>(This dataset is not fetched or set via Planning Data)</p>",
+          fn: "property.constraints.planning",
+          text: "Are you in flood zone 1? (again)",
+          neverAutoAnswer: false,
+        },
+        edges: ["FloodZone1YesAgain", "FloodZone1NoAgain"],
+      },
+      FloodZone1YesAgain: {
+        type: 200,
+        data: {
+          text: "Yes (again)",
+          val: "flood.zone.1",
+        },
+      },
+      FloodZone1NoAgain: {
+        type: 200,
+        data: {
+          text: "No (again)",
+        },
+      },
+    };
+    resetPreview();
+    setState({ flow: alteredFlow });
+
+    expect(upcomingCardIds()).toEqual([
+      "PlanningConstraints",
+      "ConservationAreaQuestion",
+      "Article4Question",
+      "FloodZone1Question",
+      "FloodZone1QuestionAgain",
+    ]);
+
+    // Manually proceed forward through PlanningConstraints as if we've checked 4x datasets: Article 4, Conservation Area, Flood Zone 2, Flood Zone 3
+    clickContinue("PlanningConstraints", {
+      data: {
+        "property.constraints.planning": ["article4"],
+        _nots: {
+          "property.constraints.planning": [
+            "designated.conservationArea",
+            "flood.zone.2",
+            "flood.zone.3",
+          ],
+        },
+      },
+      auto: false,
+    });
+
+    expect(computePassport()?.data?.["property.constraints.planning"]).toEqual(["article4"]);
+    expect(computePassport()?.data?.["_nots"]?.["property.constraints.planning"]).toEqual(["designated.conservationArea", "flood.zone.2", "flood.zone.3"]);
+
+    // Proceed through auto-answerable questions
+    clickContinue("ConservationAreaQuestion", { answers: autoAnswerableOptions("ConservationAreaQuestion"), auto: true });
+    clickContinue("Article4Question", { answers: autoAnswerableOptions("Article4Question"), auto: true });
+
+    // Confirm passport is in same state
+    expect(computePassport()?.data?.["property.constraints.planning"]).toEqual(["article4"]);
+    expect(computePassport()?.data?.["_nots"]?.["property.constraints.planning"]).toEqual(["designated.conservationArea", "flood.zone.2", "flood.zone.3"]);
+
+    // Manually proceed through the first Flood Zone 1 Question, and expect second occurance to be auto-answered because no longer unseen option
+    expect(autoAnswerableOptions("FloodZone1Question")).toBeUndefined();
+    clickContinue("FloodZone1Question", { answers: ["FloodZone1No"], auto: false });
+    expect(upcomingCardIds()).toEqual(["FloodZone1QuestionAgain"]);
+    expect(autoAnswerableOptions("FloodZone1QuestionAgain")).toEqual(["FloodZone1NoAgain"]);
+  });
+
+  test("A less granular option is not auto-answered if the passport only has a more granular option (positive intersecting contraints)", () => {
+    const alteredFlow = {
+      ...flow,
+      _root: {
+        edges: [
+          "PlanningConstraints",
+          "ConservationAreaQuestion",
+          "Article4Question",
+          "FloodZone1Question", // flood.zone.1 is NOT fetched or set by Planning Data
+          "DesignatedLandQuestion",
+        ],
+      },
+      DesignatedLandQuestion: {
+        type: 100,
+        data: {
+          fn: "property.constraints.planning",
+          text: "Are you on designated land?",
+          neverAutoAnswer: false,
+        },
+        edges: ["DesignatedYes", "DesignatedNo"],
+      },
+      DesignatedYes: {
+        type: 200,
+        data: {
+          text: "Yes",
+          val: "designated",
+        },
+      },
+      DesignatedNo: {
+        type: 200,
+        data: {
+          text: "No",
+        },
+      },
+    };
+    resetPreview();
+    setState({ flow: alteredFlow });
+
+    // Manually proceed forward through PlanningConstraints as if we've checked 1 dataset: Conservation Area
+    clickContinue("PlanningConstraints", {
+      data: {
+        "property.constraints.planning": ["designated.conservationArea"],
+      },
+      auto: false,
+    });
+
+    expect(computePassport()?.data?.["property.constraints.planning"]).toEqual(["designated.conservationArea"]);
+
+    // Planning constraints should exact-match only, never `startsWith`, therefore put to user
+    expect(autoAnswerableOptions("DesignatedLandQuestion")).toBeUndefined();
+  });
+
+  test("A less granular option is not auto-answered if the passport only has a more granular option (_nots)", () => {
+    const alteredFlow = {
+      ...flow,
+      _root: {
+        edges: [
+          "PlanningConstraints",
+          "ConservationAreaQuestion",
+          "Article4Question",
+          "FloodZone1Question", // flood.zone.1 is NOT fetched or set by Planning Data
+          "DesignatedLandQuestion",
+        ],
+      },
+      DesignatedLandQuestion: {
+        type: 100,
+        data: {
+          fn: "property.constraints.planning",
+          text: "Are you on designated land?",
+          neverAutoAnswer: false,
+        },
+        edges: ["DesignatedYes", "DesignatedNo"],
+      },
+      DesignatedYes: {
+        type: 200,
+        data: {
+          text: "Yes",
+          val: "designated",
+        },
+      },
+      DesignatedNo: {
+        type: 200,
+        data: {
+          text: "No",
+        },
+      },
+    };
+    resetPreview();
+    setState({ flow: alteredFlow });
+
+    // Manually proceed forward through PlanningConstraints as if we've checked 1 dataset: Conservation Area
+    clickContinue("PlanningConstraints", {
+      data: {
+        "_nots": {
+          "property.constraints.planning": ["designated.conservationArea"],
+        }
+      },
+      auto: false,
+    });
+
+    expect(computePassport()?.data?.["_nots"]?.["property.constraints.planning"]).toEqual(["designated.conservationArea"]);
+    expect(computePassport()?.data?.["property.constraints.planning"]).toBeUndefined();
+
+    // Planning constraints should exact-match only, never `startsWith`, therefore put to user
+    expect(autoAnswerableOptions("DesignatedLandQuestion")).toBeUndefined();
+  });
+});
+
+const flow: Store.Flow = {
+  _root: {
+    edges: [
+      "PlanningConstraints",
+      "ConservationAreaQuestion",
+      "Article4Question",
+      "FloodZone1Question", // flood.zone.1 is NOT fetched or set by Planning Data
+    ],
+  },
+  PlanningConstraints: {
+    type: 11,
+    data: {
+      title: "Planning constraints",
+      description:
+        "Planning constraints might limit how you can develop or use the property",
+      fn: "property.constraints.planning",
+      disclaimer:
+        "<p><strong>This page does not include information about historic planning conditions that may apply to this property.</strong></p>",
+    },
+  },
+  ConservationAreaQuestion: {
+    type: 100,
+    data: {
+      fn: "property.constraints.planning",
+      text: "Are you in a conservation area?",
+      neverAutoAnswer: false,
+      tags: [],
+    },
+    edges: ["ConservationAreaYes", "ConservationAreaNo"],
+  },
+  ConservationAreaYes: {
+    type: 200,
+    data: {
+      text: "Yes",
+      val: "designated.conservationArea",
+    },
+  },
+  ConservationAreaNo: {
+    type: 200,
+    data: {
+      text: "No",
+    },
+  },
+  Article4Question: {
+    type: 100,
+    data: {
+      fn: "property.constraints.planning",
+      text: "Do any Article 4 directions apply?",
+      neverAutoAnswer: false,
+    },
+    edges: ["Article4Yes", "Article4No"],
+  },
+  Article4Yes: {
+    type: 200,
+    data: {
+      text: "Yes",
+      val: "article4",
+    },
+  },
+  Article4No: {
+    type: 200,
+    data: {
+      text: "No",
+    },
+  },
+  FloodZone1Question: {
+    type: 100,
+    data: {
+      description:
+        "<p>(This dataset is not fetched or set via Planning Data)</p>",
+      fn: "property.constraints.planning",
+      text: "Are you in flood zone 1?",
+      neverAutoAnswer: false,
+    },
+    edges: ["FloodZone1Yes", "FloodZone1No"],
+  },
+  FloodZone1Yes: {
+    type: 200,
+    data: {
+      text: "Yes",
+      val: "flood.zone.1",
+    },
+  },
+  FloodZone1No: {
+    type: 200,
+    data: {
+      text: "No",
+    },
+  },
+};
diff --git a/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts b/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts
index b9b754f72b..7a02cff31b 100644
--- a/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts
+++ b/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts
@@ -555,21 +555,23 @@ export const previewStore: StateCreator<
     const sortedOptionVals: string[] = sortedOptions.map(
       (option) => option.data?.val,
     );
+    const hasVisitedEveryOption = sortedOptionVals.every((value) =>
+      visitedOptionVals.includes(value),
+    );
     const blankOption = options.find((option) => !option.data?.val);
+
     let optionsThatCanBeAutoAnswered: Array<NodeId> = [];
 
-    // Get existing passport value(s) for this node's fn
+    // Get existing passport value(s) for this node's fn, accounting for Planning Constraints special `_nots`
     const passportValues = passport.data?.[data.fn];
+    const nots: string[] | undefined = passport.data?.["_nots"]?.[planningConstraintsFn];
 
-    // Planning constraints use a bespoke "_nots" structure to differentiate intersecting & not-intersecting passport values and therefore require special automation rules later
-    const nots: string[] | undefined =
-      passport.data?.["_nots"]?.[planningConstraintsFn];
-
-    // If we have existing passport value(s) for this fn in an eligible automation format (eg not numbers or plain strings),
-    //   then proceed through the matching option(s) or the blank option independent if other vals have been seen before
     const foundPassportValues =
       Array.isArray(passportValues) && passportValues.length > 0;
-    if (foundPassportValues) {
+    
+    // If we have existing passport value(s) for this fn in an eligible automation format (eg not numbers or plain strings),
+    //   then proceed through the matching option(s) or the blank option independent if other vals have been seen before
+    if (foundPassportValues && data.fn !== planningConstraintsFn) {
       // Check if the existing passport value(s) startsWith at least one option's val (eg passport retains most granular values only)
       const matchingPassportValues = passportValues.filter(
         (passportValue: any) =>
@@ -597,31 +599,52 @@ export const previewStore: StateCreator<
           });
         });
       } else {
-        // Planning constraints may have foundPassportValues (intersecting constraints only) in addition to nots
-        //   ensure the blank option is only only auto-answered if the not-blank option values are valid constraints that we checked (intersecting or not)
-        if (data.fn === planningConstraintsFn) {
-          if (blankOption?.id && nots) {
-            const seenPlanningConstraintVals =
-              sortedOptionVals.concat(visitedOptionVals);
-            if (seenPlanningConstraintVals.some((val) => nots.includes(val)))
-              optionsThatCanBeAutoAnswered.push(blankOption?.id);
-          }
-        } else if (blankOption?.id) {
+        if (blankOption?.id) { optionsThatCanBeAutoAnswered.push(blankOption.id) };
+      }
+    }
+
+    if (data.fn === planningConstraintsFn && (foundPassportValues || nots)) {
+      // Planning constraints queried from an external source are stored via two separate passport vars: 
+      //   - One for intersections aka `planningConstraintsFn`
+      //   - Another for not-intersections aka `_nots`
+      const matchingIntersectingConstraints = passportValues?.filter(
+        (passportValue: any) =>
+          sortedOptions.some((option) => passportValue === option.data?.val)
+      );
+      const matchingNots = nots?.filter(
+        (not) => sortedOptions.some((option => not === option.data?.val))
+      );
+
+      if (matchingIntersectingConstraints?.length > 0) {
+        // Planning constraints uniquely store passport values for every level of granularity (eg `listed`, `listed.grade.I`)
+        //   So only auto-answer based on exact matches and do not apply `startsWith` logic
+        sortedOptions.forEach((option) => {
+          passportValues.forEach((passportValue: any) => {
+            if (passportValue === option.data?.val) {
+              if (option.id) optionsThatCanBeAutoAnswered.push(option.id);
+            }
+          });
+        });
+      } else if (matchingNots && matchingNots.length > 0) {
+        // Nots are planning constraints that were queried, but do not apply, therefore we automate through the blank
+        sortedOptions.forEach((option) => {
+          nots?.forEach((not) => {
+            if (not === option.data?.val) {
+              if (blankOption?.id) optionsThatCanBeAutoAnswered.push(blankOption.id);
+            }
+          });
+        });
+      } else {
+        // If this node is asking about a constraint that we have NOT queried from an external source, 
+        //   Then put it to the user exactly once and automate future instances of it
+        if (blankOption?.id && hasVisitedEveryOption)
           optionsThatCanBeAutoAnswered.push(blankOption.id);
-        }
       }
     }
 
-    // If we don't have any existing passport values for this fn but we do have a blank option,
-    //  proceed through the blank if every option's val has been visited before
     if (!foundPassportValues) {
-      // Planning Constraints use a bespoke "_nots" data structure to describe all option vals returned via GIS API
-      //   Concat these onto other visitedOptionVals so that questions about constraints we haven't fetched are put to user exactly once
-      if (nots) visitedOptionVals = visitedOptionVals.concat(nots);
-
-      const hasVisitedEveryOption = sortedOptionVals.every((value) =>
-        visitedOptionVals.includes(value),
-      );
+      // If we don't have any existing passport values for this fn but we do have a blank option,
+      //  proceed through the blank if every option's val has been visited before
       if (blankOption?.id && hasVisitedEveryOption)
         optionsThatCanBeAutoAnswered.push(blankOption.id);
     }
@@ -809,9 +832,9 @@ export const sortBreadcrumbs = (
   return editingNodes?.length
     ? nextBreadcrumbs
     : sortIdsDepthFirst(flow)(new Set(Object.keys(nextBreadcrumbs))).reduce(
-        (acc, id) => ({ ...acc, [id]: nextBreadcrumbs[id] }),
-        {} as Store.Breadcrumbs,
-      );
+      (acc, id) => ({ ...acc, [id]: nextBreadcrumbs[id] }),
+      {} as Store.Breadcrumbs,
+    );
 };
 
 function handleNodesWithPassport({

From 5dc38137c849442cb781718a61d6dd328d97d029 Mon Sep 17 00:00:00 2001
From: Jessica McInchak <jessica.mcinchak@gmail.com>
Date: Fri, 6 Dec 2024 12:01:46 +0100
Subject: [PATCH 9/9] adjust compute passport too

---
 editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts b/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts
index 7a02cff31b..add41d41eb 100644
--- a/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts
+++ b/editor.planx.uk/src/pages/FlowEditor/lib/store/preview.ts
@@ -223,7 +223,9 @@ export const previewStore: StateCreator<
           if (passportValue.length > 0) {
             const existingValue = acc.data?.[key] ?? [];
 
-            const combined = passportValue
+            const combined = key === planningConstraintsFn 
+              ? passportValue.concat(existingValue) // Planning constraints uniquely store all-levels of granularity, rather than most granular only
+              : passportValue
               .concat(existingValue)
               .reduce(
                 (acc: string[], curr: string, _i: number, arr: string[]) => {