Configurable metrics and the visits wizard 🧙‍♂️

src/app/beta/orgs/[orgId]/canvassassignments/[canvassAssId]/assignees/[assigneeId]/route.ts

@@ -1,7 +1,7 @@
 import mongoose from 'mongoose';
 import { NextRequest, NextResponse } from 'next/server';
 
-import { CanvassAssigneeModel } from 'features/areas/models';
+import { CanvassAssigneeModel } from 'features/canvassAssignments/models';
 import asOrgAuthorized from 'utils/api/asOrgAuthorized';
 
 type RouteMeta = {

src/app/beta/orgs/[orgId]/canvassassignments/[canvassAssId]/assignees/route.ts

@@ -1,9 +1,9 @@
 import mongoose from 'mongoose';
 import { NextRequest } from 'next/server';
 
+import { ZetkinCanvassAssignee } from 'features/canvassAssignments/types';
+import { CanvassAssigneeModel } from 'features/canvassAssignments/models';
 import asOrgAuthorized from 'utils/api/asOrgAuthorized';
-import { CanvassAssigneeModel } from 'features/areas/models';
-import { ZetkinCanvassAssignee } from 'features/areas/types';
 
 type RouteMeta = {
   params: {

src/app/beta/orgs/[orgId]/canvassassignments/[canvassAssId]/route.ts

@@ -2,8 +2,11 @@ import mongoose from 'mongoose';
 import { NextRequest, NextResponse } from 'next/server';
 
 import asOrgAuthorized from 'utils/api/asOrgAuthorized';
-import { CanvassAssignmentModel } from 'features/areas/models';
-import { ZetkinCanvassAssignment } from 'features/areas/types';
+import { CanvassAssignmentModel } from 'features/canvassAssignments/models';
+import {
+  ZetkinCanvassAssignment,
+  ZetkinMetric,
+} from 'features/canvassAssignments/types';
 
 type RouteMeta = {
   params: {
@@ -34,6 +37,13 @@ export async function GET(request: NextRequest, { params }: RouteMeta) {
       const canvassAssignment: ZetkinCanvassAssignment = {
         campaign: { id: canvassAssignmentModel.campId },
         id: canvassAssignmentModel._id.toString(),
+        metrics: (canvassAssignmentModel.metrics || []).map((metric) => ({
+          definesDone: metric.definesDone || false,
+          description: metric.description || '',
+          id: metric._id,
+          kind: metric.kind,
+          question: metric.question,
+        })),
         organization: { id: orgId },
         title: canvassAssignmentModel.title,
       };
@@ -54,14 +64,68 @@ export async function PATCH(request: NextRequest, { params }: RouteMeta) {
       await mongoose.connect(process.env.MONGODB_URL || '');
 
       const payload = await request.json();
+      const { metrics: newMetrics, title } = payload;
 
-      const model = await CanvassAssignmentModel.findOneAndUpdate(
+      if (newMetrics) {
+        // Find existing metrics to remove
+        const assignment = await CanvassAssignmentModel.findById(
+          params.canvassAssId
+        ).select('metrics');
+
+        if (!assignment) {
+          return new NextResponse(null, { status: 404 });
+        }
+
+        const existingMetricsIds = assignment.metrics.map((metric) =>
+          metric._id.toString()
+        );
+
+        // Identify metrics to be deleted
+        const metricsToDelete = existingMetricsIds.filter(
+          (id) => !newMetrics.some((metric: ZetkinMetric) => metric.id === id)
+        );
+
+        // Remove metrics that are no longer included
+        if (metricsToDelete.length > 0) {
+          await CanvassAssignmentModel.updateOne(
+            { _id: params.canvassAssId },
+            { $pull: { metrics: { _id: { $in: metricsToDelete } } } }
+          );
+        }
+
+        for (const metric of newMetrics) {
+          if (metric.id) {
+            // If the metric has an ID, update it
+            await CanvassAssignmentModel.updateOne(
+              { _id: params.canvassAssId, 'metrics._id': metric.id },
+              {
+                $set: {
+                  'metrics.$.definesDone': metric.definesDone,
+                  'metrics.$.description': metric.description,
+                  'metrics.$.kind': metric.kind,
+                  'metrics.$.question': metric.question,
+                },
+              }
+            );
+          } else {
+            // If no ID exists, push it as a new metric
+            await CanvassAssignmentModel.updateOne(
+              { _id: params.canvassAssId },
+              {
+                $push: { metrics: metric },
+              }
+            );
+          }
+        }
+      }
+
+      await CanvassAssignmentModel.updateOne(
         { _id: params.canvassAssId },
-        {
-          title: payload.title,
-        },
-        { new: true }
+        { title }
       );
+      const model = await CanvassAssignmentModel.findById(
+        params.canvassAssId
+      ).populate('metrics');
 
       if (!model) {
         return new NextResponse(null, { status: 404 });
@@ -71,6 +135,13 @@ export async function PATCH(request: NextRequest, { params }: RouteMeta) {
         data: {
           campaign: { id: model.campId },
           id: model._id.toString(),
+          metrics: (model.metrics || []).map((metric) => ({
+            definesDone: metric.definesDone || false,
+            description: metric.description || '',
+            id: metric._id,
+            kind: metric.kind,
+            question: metric.question,
+          })),
           organization: { id: orgId },
           title: model.title,
         },

src/app/beta/orgs/[orgId]/canvassassignments/[canvassAssId]/sessions/route.ts

@@ -1,10 +1,11 @@
 import mongoose from 'mongoose';
 import { NextRequest, NextResponse } from 'next/server';
 
-import { AreaModel, CanvassAssignmentModel } from 'features/areas/models';
-import { ZetkinCanvassSession } from 'features/areas/types';
+import { CanvassAssignmentModel } from 'features/canvassAssignments/models';
+import { ZetkinCanvassSession } from 'features/canvassAssignments/types';
 import asOrgAuthorized from 'utils/api/asOrgAuthorized';
 import { ZetkinPerson } from 'utils/types/zetkin';
+import { AreaModel } from 'features/areas/models';
 
 type RouteMeta = {
   params: {

src/app/beta/orgs/[orgId]/canvassassignments/[canvassAssId]/stats/route.ts

@@ -1,21 +1,22 @@
 import mongoose from 'mongoose';
 import { NextRequest, NextResponse } from 'next/server';
 
+import asOrgAuthorized from 'utils/api/asOrgAuthorized';
+import { ZetkinPerson } from 'utils/types/zetkin';
+import isPointInsidePolygon from 'features/canvassAssignments/utils/isPointInsidePolygon';
 import {
-  AreaModel,
   CanvassAssignmentModel,
   PlaceModel,
-} from 'features/areas/models';
+} from 'features/canvassAssignments/models';
 import {
   Household,
   Visit,
-  ZetkinArea,
+  ZetkinCanvassAssignmentStats,
   ZetkinCanvassSession,
   ZetkinPlace,
-} from 'features/areas/types';
-import asOrgAuthorized from 'utils/api/asOrgAuthorized';
-import { ZetkinPerson } from 'utils/types/zetkin';
-import isPointInsidePolygon from 'features/areas/utils/isPointInsidePolygon';
+} from 'features/canvassAssignments/types';
+import { AreaModel } from 'features/areas/models';
+import { ZetkinArea } from 'features/areas/types';
 
 type RouteMeta = {
   params: {
@@ -35,40 +36,40 @@ export async function GET(request: NextRequest, { params }: RouteMeta) {
       await mongoose.connect(process.env.MONGODB_URL || '');
 
       //Find all sessions of the assignment
-      const model = await CanvassAssignmentModel.findOne({
+      const assignmentModel = await CanvassAssignmentModel.findOne({
         _id: params.canvassAssId,
       });
 
-      if (!model) {
+      if (!assignmentModel) {
         return new NextResponse(null, { status: 404 });
       }
 
       const sessions: ZetkinCanvassSession[] = [];
 
-      for await (const sessionData of model.sessions) {
+      for await (const sessionData of assignmentModel.sessions) {
         const person = await apiClient.get<ZetkinPerson>(
           `/api/orgs/${orgId}/people/${sessionData.personId}`
         );
-        const area = await AreaModel.findOne({
+        const areaModel = await AreaModel.findOne({
           _id: sessionData.areaId,
         });
 
-        if (area && person) {
+        if (areaModel && person) {
           sessions.push({
             area: {
-              description: area.description,
-              id: area._id.toString(),
+              description: areaModel.description,
+              id: areaModel._id.toString(),
               organization: {
                 id: orgId,
               },
-              points: area.points,
+              points: areaModel.points,
               tags: [], //TODO: Is this really neccessary here?
-              title: area.title,
+              title: areaModel.title,
             },
             assignee: person,
             assignment: {
-              id: model._id.toString(),
-              title: model.title,
+              id: assignmentModel._id.toString(),
+              title: assignmentModel.title,
             },
           });
         }
@@ -90,7 +91,6 @@ export async function GET(request: NextRequest, { params }: RouteMeta) {
         orgId: orgId,
         position: model.position,
         title: model.title,
-        type: model.type,
       }));
 
       type PlaceWithAreaId = ZetkinPlace & { areaId: ZetkinArea['id'] };
@@ -116,10 +116,55 @@ export async function GET(request: NextRequest, { params }: RouteMeta) {
       ];
 
       const visitsInAreas: Visit[] = [];
+      const successfulVisitsInAreas: Visit[] = [];
       const visitedPlacesInAreas: string[] = [];
       const visitedAreas: string[] = [];
       const householdsInAreas: Household[] = [];
 
+      const configuredMetrics = assignmentModel.metrics;
+      const idOfMetricThatDefinesDone = configuredMetrics.find(
+        (metric) => metric.definesDone
+      )?._id;
+      const accumulatedMetrics: ZetkinCanvassAssignmentStats['metrics'] =
+        configuredMetrics.map((metric) => ({
+          metric: {
+            definesDone: metric.definesDone,
+            description: metric.description,
+            id: metric._id,
+            kind: metric.kind,
+            question: metric.question,
+          },
+          values: metric.kind == 'boolean' ? [0] : [0, 0, 0, 0, 0],
+        }));
+
+      allPlaces.forEach((place) => {
+        place.households.forEach((household) => {
+          household.visits.forEach((visit) => {
+            if (visit.canvassAssId == params.canvassAssId) {
+              visit.responses.forEach((response) => {
+                const configuredMetric = configuredMetrics.find(
+                  (candidate) => candidate._id == response.metricId
+                );
+
+                const accumulatedMetric = accumulatedMetrics.find(
+                  (accum) => accum.metric.id == response.metricId
+                );
+
+                if (accumulatedMetric && configuredMetric) {
+                  if (response.response == 'yes') {
+                    accumulatedMetric.values[0]++;
+                  } else if (configuredMetric.kind == 'scale5') {
+                    const rating = parseInt(response.response);
+                    const index = rating - 1;
+                    accumulatedMetric.values[index]++;
+                  }
+                }
+              });
+            }
+          });
+        });
+      });
+
       uniquePlacesInAreas.forEach((place) => {
         householdsInAreas.push(...place.households);
         place.households.forEach((household) => {
@@ -128,6 +173,14 @@ export async function GET(request: NextRequest, { params }: RouteMeta) {
               visitedAreas.push(place.areaId);
               visitedPlacesInAreas.push(place.id);
               visitsInAreas.push(visit);
+
+              visit.responses.forEach((response) => {
+                if (response.metricId == idOfMetricThatDefinesDone) {
+                  if (response.response == 'yes') {
+                    successfulVisitsInAreas.push(visit);
+                  }
+                }
+              });
             }
           });
         });
@@ -156,9 +209,11 @@ export async function GET(request: NextRequest, { params }: RouteMeta) {
 
       return Response.json({
         data: {
+          metrics: accumulatedMetrics,
           num_areas: uniqueAreas.length,
           num_households: householdsInAreas.length,
           num_places: uniquePlacesInAreas.length,
+          num_successful_visited_households: successfulVisitsInAreas.length,
           num_visited_areas: Array.from(new Set(visitedAreas)).length,
           num_visited_households: visitsInAreas.length,
           num_visited_households_outside_areas: visitsOutsideAreas.length,

src/app/beta/orgs/[orgId]/canvassassignments/route.ts

@@ -2,7 +2,7 @@ import mongoose from 'mongoose';
 import { NextRequest, NextResponse } from 'next/server';
 
 import asOrgAuthorized from 'utils/api/asOrgAuthorized';
-import { CanvassAssignmentModel } from 'features/areas/models';
+import { CanvassAssignmentModel } from 'features/canvassAssignments/models';
 
 type RouteMeta = {
   params: {
@@ -28,6 +28,13 @@ export async function GET(request: NextRequest, { params }: RouteMeta) {
             id: assignment.campId,
           },
           id: assignment._id.toString(),
+          metrics: (assignment.metrics || []).map((metric) => ({
+            definesDone: metric.definesDone || false,
+            description: metric.description || '',
+            id: metric._id,
+            kind: metric.kind,
+            question: metric.question,
+          })),
           organization: {
             id: orgId,
           },
@@ -52,6 +59,7 @@ export async function POST(request: NextRequest, { params }: RouteMeta) {
 
       const model = new CanvassAssignmentModel({
         campId: payload.campaign_id,
+        metrics: payload.metrics || [],
         orgId: orgId,
         title: payload.title,
       });
@@ -62,6 +70,13 @@ export async function POST(request: NextRequest, { params }: RouteMeta) {
         data: {
           campaign: { id: model.campId },
           id: model._id.toString(),
+          metrics: model.metrics.map((metric) => ({
+            definesDone: metric.definesDone || false,
+            description: metric.description || '',
+            id: metric._id,
+            kind: metric.kind,
+            question: metric.question,
+          })),
           organization: { id: orgId },
           title: model.title,
         },