chore: update ODP schema mapping to v0.2.0

src/export/digitalPlanning/mocks/lawfulDevelopmentCertificate.ts

@@ -5,6 +5,7 @@ export const mockLDCESession = {
     slug: "apply-for-a-lawful-development-certificate",
     team: {
       slug: "buckinghamshire",
+      referenceCode: "BKM",
     },
   },
   created_at: "2023-09-01T06:11:24.502169+00:00",
@@ -4505,6 +4506,7 @@ export const mockLDCPSession = {
     slug: "apply-for-a-lawful-development-certificate",
     team: {
       slug: "buckinghamshire",
+      referenceCode: "BKM",
     },
   },
   created_at: "2023-09-04T05:59:05.516553+00:00",

src/export/digitalPlanning/mocks/planningPermission.ts

@@ -5,6 +5,7 @@ export const mockPlanningPermissionSession = {
     slug: "apply-for-planning-permission",
     team: {
       slug: "lambeth",
+      referenceCode: "LBH",
     },
   },
   created_at: "2023-08-31T17:33:46.22695+00:00",

src/export/digitalPlanning/mocks/priorApproval.ts

@@ -5,6 +5,7 @@ export const mockPriorApprovalSession = {
     slug: "apply-for-prior-approval",
     team: {
       slug: "southwark",
+      referenceCode: "SWK",
     },
   },
   created_at: "2023-09-02T13:36:24.49483+00:00",

src/export/digitalPlanning/model.test.ts

@@ -12,8 +12,11 @@ import { mockPriorApprovalSession } from "./mocks/priorApproval";
 import { DigitalPlanning } from "./model";
 
 // `getPlanningConstraints` relies on an accurate teamSlug to be available, other vars can be be mocked
-const mockMetadataForSession = (teamSlug: string): SessionMetadata => ({
-  id: "session123",
+const mockMetadataForSession = (
+  teamSlug: string,
+  referenceCode: string,
+): SessionMetadata => ({
+  id: "c06eebb7-6201-4bc0-9fe7-ec5d7a1c0797",
   createdAt: "2023-01-01 00:00:00",
   submittedAt: "2023-01-02 00:00:00",
   flow: {
@@ -22,6 +25,7 @@ const mockMetadataForSession = (teamSlug: string): SessionMetadata => ({
     team: {
       name: teamSlug,
       slug: teamSlug,
+      referenceCode: referenceCode,
     },
   },
 });
@@ -33,21 +37,30 @@ const mockSessions = [
     passport: new Passport({ data: { ...mockLDCPSession.passport } }),
     breadcrumbs: mockLDCPSession.breadcrumbs as Breadcrumbs,
     flow: mockPublishedLDCFlow,
-    metadata: mockMetadataForSession(mockLDCPSession.flow.team.slug),
+    metadata: mockMetadataForSession(
+      mockLDCPSession.flow.team.slug,
+      mockLDCPSession.flow.team.referenceCode,
+    ),
   },
   {
     name: "LDC - Existing",
     passport: new Passport({ data: { ...mockLDCESession.passport } }),
     breadcrumbs: mockLDCESession.breadcrumbs as Breadcrumbs,
     flow: mockPublishedLDCFlow,
-    metadata: mockMetadataForSession(mockLDCESession.flow.team.slug),
+    metadata: mockMetadataForSession(
+      mockLDCESession.flow.team.slug,
+      mockLDCESession.flow.team.referenceCode,
+    ),
   },
   {
     name: "Prior Approval",
     passport: new Passport({ data: { ...mockPriorApprovalSession.passport } }),
     breadcrumbs: mockPriorApprovalSession.breadcrumbs as Breadcrumbs,
     flow: mockPublishedPriorApprovalFlow,
-    metadata: mockMetadataForSession(mockPriorApprovalSession.flow.team.slug),
+    metadata: mockMetadataForSession(
+      mockPriorApprovalSession.flow.team.slug,
+      mockPriorApprovalSession.flow.team.referenceCode,
+    ),
   },
   {
     name: "Planning Permission",
@@ -58,25 +71,29 @@ const mockSessions = [
     flow: mockPublishedPlanningPermissionFlow,
     metadata: mockMetadataForSession(
       mockPlanningPermissionSession.flow.team.slug,
+      mockPlanningPermissionSession.flow.team.referenceCode,
     ),
   },
 ];
 
 // We don't need to iterate over application types when testing invalid payloads
 const mockParams = {
-  sessionId: "session123",
+  sessionId: "c06eebb7-6201-4bc0-9fe7-ec5d7a1c0797",
   passport: new Passport({ data: { ...mockLDCPSession.passport } }),
   breadcrumbs: mockLDCPSession.breadcrumbs,
   flow: mockPublishedLDCFlow,
-  metadata: mockMetadataForSession(mockLDCPSession.flow.team.slug),
+  metadata: mockMetadataForSession(
+    mockLDCPSession.flow.team.slug,
+    mockLDCPSession.flow.team.referenceCode,
+  ),
 };
 
 describe("DigitalPlanning", () => {
   describe("getPayload", () => {
     mockSessions.forEach((mock) => {
       it(`should return valid payload (${mock.name})`, () => {
         const instance = new DigitalPlanning({
-          sessionId: "session123",
+          sessionId: "c06eebb7-6201-4bc0-9fe7-ec5d7a1c0797",
           passport: mock.passport,
           breadcrumbs: mock.breadcrumbs,
           flow: mock.flow,
@@ -126,7 +143,7 @@ describe("DigitalPlanning", () => {
       test("incorrect string format", () => {
         const instance = new DigitalPlanning(mockParams);
 
-        instance.payload.metadata.service.url =
+        instance.payload.metadata.schema =
           "not a valid URL, but still a string";
 
         expect(() => instance.getPayload()).toThrowError(
@@ -137,7 +154,7 @@ describe("DigitalPlanning", () => {
       test("incorrect datetime format", () => {
         const instance = new DigitalPlanning(mockParams);
 
-        instance.payload.metadata.session.submittedAt =
+        instance.payload.metadata.submittedAt =
           "not a valid datetime, but still a string";
 
         expect(() => instance.getPayload()).toThrowError(

src/export/digitalPlanning/model.ts

@@ -1,6 +1,5 @@
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
-import capitalize from "lodash.capitalize";
 import set from "lodash.set";
 
 import { Passport } from "../../models";
@@ -25,7 +24,8 @@ import {
   FileType,
   GeoJSON,
   LondonProperty,
-  PlanningConstraint,
+  PlanningDesignation,
+  PlanXMetadata,
   ProjectType,
   Proposal,
   SiteContact,
@@ -92,7 +92,7 @@ export class DigitalPlanning {
         },
         proposal: this.getProposal(),
       },
-      result: this.getResult(),
+      preAssessment: this.getResult(),
       responses: this.getResponses(),
       files: this.getFiles(),
       metadata: this.getMetadata(),
@@ -126,6 +126,19 @@ export class DigitalPlanning {
     )[0]?.properties["description"].const;
   }
 
+  /**
+   * For a Planx passport value, find it's corresponding description in the JSON schema Definition for UnionTypes
+   */
+  private findDescriptionFromValueUnionType(
+    definition: string,
+    value: string,
+  ): string {
+    return jsonSchema["definitions"][definition]["anyOf"][0]["anyOf"].filter(
+      (types: Record<string, string>) =>
+        types.properties["value"].const === value,
+    )[0]?.properties["description"].const;
+  }
+
   /**
    * Cast a string to a boolean
    */
@@ -340,7 +353,7 @@ export class DigitalPlanning {
           this.passport.data?.["property.type"]?.[0],
         ),
       },
-      constraints: this.getPlanningConstraints(),
+      planning: this.getPlanningConstraints(),
       // Only include the 'boundary' key in cases where we have digital data, not an uploaded location plan
       ...(this.passport.data?.["property.boundary.site"] && {
         boundary: this.getBoundary(),
@@ -371,26 +384,26 @@ export class DigitalPlanning {
     }
   }
 
-  private getPlanningConstraints(): Payload["data"]["property"]["constraints"] {
-    const data: PlanningConstraint[] = [];
+  private getPlanningConstraints(): Payload["data"]["property"]["planning"] {
     const teamSlug: string = this.metadata.flow.team.slug;
-    const constraints =
-      this.passport.generic<EnhancedGISResponse[]>("_constraints");
+    const constraints = this.passport.data
+      ?._constraints as unknown as EnhancedGISResponse[];
+    const designations: PlanningDesignation[] = [];
 
     constraints?.forEach((response: EnhancedGISResponse) => {
       response.constraints &&
         Object.entries(response.constraints)
           .filter(([key, _constraint]) => !key.split(".").includes(teamSlug))
           .map(([key, constraint]) => {
             if (constraint.value) {
-              data.push({
+              // Intersecting constraints
+              designations.push({
                 value: key,
-                description: this.findDescriptionFromValue(
-                  "PlanningConstraint",
+                description: this.findDescriptionFromValueUnionType(
+                  "PlanningDesignation",
                   key,
                 ),
-                category: constraint.category,
-                overlaps: constraint.value,
+                intersects: constraint.value,
                 entities:
                   constraint.data?.map(
                     (entity) =>
@@ -403,23 +416,24 @@ export class DigitalPlanning {
                             : `https://planinng.data.gov.uk/entity/${entity.id}`,
                       },
                   ) || [],
-              } as PlanningConstraint);
+              } as PlanningDesignation);
             } else {
-              data.push({
+              // Non-intersecting constraints
+              designations.push({
                 value: key,
-                description: this.findDescriptionFromValue(
-                  "PlanningConstraint",
+                description: this.findDescriptionFromValueUnionType(
+                  "PlanningDesignation",
                   key,
                 ),
-                category: constraint.category,
-                overlaps: constraint.value,
-              } as PlanningConstraint);
+                intersects: constraint.value,
+              } as PlanningDesignation);
             }
           });
     });
 
     return {
-      planning: data,
+      sources: constraints?.map((constraint) => constraint.planxRequest) || [],
+      designations: designations,
     };
   }
 
@@ -496,7 +510,7 @@ export class DigitalPlanning {
   }
 
   // @todo getResult() should support flagsets beyond Planning Permission
-  private getResult(): Payload["result"] {
+  private getResult(): Payload["preAssessment"] {
     // Planning Permission application types won't have a Planning Permission result right now
     if (this.passport.data?.["application.type"]?.[0].startsWith("pp")) {
       return [];
@@ -513,7 +527,7 @@ export class DigitalPlanning {
           value: title,
           description: this.findDescriptionFromValue("ResultFlag", title), // flag.description may be custom text
         },
-      ] as Payload["result"];
+      ] as Payload["preAssessment"];
     }
   }
 
@@ -745,21 +759,15 @@ export class DigitalPlanning {
 
   private getMetadata(): Payload["metadata"] {
     return {
+      id: this.sessionId,
+      organisation: this.metadata.flow.team.referenceCode,
+      submittedAt: this.metadata.submittedAt,
+      source: "PlanX",
       service: {
         flowId: this.metadata.flow.id,
-        name: capitalize(this.metadata.flow.slug.replaceAll?.("-", " ")),
-        owner: this.metadata.flow.team.slug,
         url: `https://www.editor.planx.uk/${this.metadata.flow.team.slug}/${this.metadata.flow.slug}/preview`,
       },
-      session: {
-        source: "PlanX",
-        id: this.sessionId,
-        createdAt: this.metadata.createdAt,
-        submittedAt: this.metadata.submittedAt,
-      },
-      schema: {
-        url: `https://theopensystemslab.github.io/digital-planning-data-schemas/${jsonSchema["$id"]}/schema.json`,
-      },
-    };
+      schema: `https://theopensystemslab.github.io/digital-planning-data-schemas/${jsonSchema["$id"]}/schema.json`,
+    } as PlanXMetadata;
   }
 }