[new script] events detect-external-orgunits

README.md

@@ -183,6 +183,16 @@ Expected format of `xlsx` file:
 
 ## Events
 
+### Detect events assigned to organisation units outside their enrollment
+
+When enrollments are transferred to another org unit, the existing events keep their original org unit. While that's the expected default behaviour, sometimes we need to detect and fix these mismatches:
+
+```shell
+$ yarn start:dev events detect-orgunits-outside-enrollment \
+  --url "http://localhost:8080" --auth "USER:PASS" \
+  --notify-email="SUBJECT,EMAIL1,EMAIL2,..."
+```
+
 ### Move events from one orgunit to another
 
 Move events for program events (so no enrollments/TEIs move is supported):

src/data/CategoryOptionD2Repository.ts

@@ -74,26 +74,28 @@ export class CategoryOptionD2Repository implements CategoryOptionRepository {
                 {
                     recordsSkipped: saveResponse.status === "ERROR" ? catOptionsToSave.map(co => co.id) : [],
                     errorMessage,
-                    created: saveResponse.response.stats.created,
-                    ignored: saveResponse.response.stats.ignored,
-                    updated: saveResponse.response.stats.updated,
+                    ...saveResponse.response.stats,
                 },
             ];
         });
 
         return stats.reduce(
-            (acum, stat) => {
+            (acum, stat): Stats => {
                 return {
                     recordsSkipped: [...acum.recordsSkipped, ...stat.recordsSkipped],
                     errorMessage: `${acum.errorMessage}${stat.errorMessage}`,
                     created: acum.created + stat.created,
                     ignored: acum.ignored + stat.ignored,
                     updated: acum.updated + stat.updated,
+                    deleted: acum.deleted + stat.deleted,
+                    total: acum.total + stat.total,
                 };
             },
             {
                 recordsSkipped: [],
                 errorMessage: "",
+                deleted: 0,
+                total: 0,
                 created: 0,
                 ignored: 0,
                 updated: 0,

src/data/D2Tracker.ts

@@ -5,11 +5,18 @@
 import { Stats } from "domain/entities/Stats";
 import { D2Api } from "types/d2-api";
 import log from "utils/log";
+import { TrackerPostRequest } from "@eyeseetea/d2-api/api/tracker";
+import { TrackedEntitiesGetResponse } from "@eyeseetea/d2-api/api/trackerTrackedEntities";
+import { TrackerEnrollmentsResponse } from "@eyeseetea/d2-api/api/trackerEnrollments";
+import { TrackerEventsResponse } from "@eyeseetea/d2-api/api/trackerEvents";
 
 export class D2Tracker {
     constructor(private api: D2Api) {}
 
-    async postTracker(key: TrackerDataKey, objects: object[]): Async<TrackerResponse[]> {
+    async postTracker<Key extends TrackerDataKey>(
+        key: Key,
+        objects: Array<NonNullable<TrackerPostRequest[Key]>[number]>
+    ): Async<TrackerResponse[]> {
         const total = objects.length;
         log.info(`Import data: ${key} - Total: ${total}`);
         let page = 1;
@@ -29,17 +36,21 @@
         return result;
     }
 
-    private async postTrackerData(data: object, options: { payloadId: string }): Async<TrackerResponse> {
-        const response: TrackerResponse = await this.api
-            .post<TrackerResponse>("/tracker", { async: false }, data)
+    private async postTrackerData(
+        data: TrackerPostRequest,
+        options: { payloadId: string }
+    ): Async<TrackerResponse> {
+        const response: TrackerResponse = await this.api.tracker
+            .post({ async: false }, data)
             .getData()
-            .catch(err => {
-                if (err?.response?.data) {
-                    return err.response.data as TrackerResponse;
+            .then(res => ({ ...res, stats: { ...Stats.empty(), ...res.stats } }))
+            .catch((err): TrackerResponse => {
+                const data = err?.response?.data;
+                if (data) {
+                    return data;
                 } else {
                     return {
                         status: "ERROR",
-                        typeReports: [],
                         stats: Stats.empty(),
                     };
                 }
@@ -56,37 +67,47 @@
         }
     }
 
-    async getFromTracker<T>(
-        apiPath: string,
+    async getFromTracker<Key extends TrackerDataKey>(
+        model: Key,
         options: {
             programIds: string[];
             orgUnitIds: string[] | undefined;
-            fields?: string;
             trackedEntity?: string | undefined;
         }
-    ): Promise<T[]> {
-        const output = [];
-        const { programIds, orgUnitIds, fields = "*", trackedEntity } = options;
+    ): Promise<Array<Mapping[Key][number]>> {
+        type Output = Array<Mapping[Key][number]>;
+
+        const output: Output = [];
+        const { programIds, orgUnitIds, trackedEntity } = options;
 
         for (const programId of programIds) {
             let page = 1;
             let dataRemaining = true;
 
             while (dataRemaining) {
                 const pageSize = 1000;
-                log.debug(`GET ${apiPath} (pageSize=${pageSize}, page=${page})`);
-
-                const { instances } = await this.api
-                    .get<{ instances: T[] }>(`/tracker/${apiPath}`, {
-                        page,
-                        pageSize: pageSize,
-                        ouMode: orgUnitIds ? "SELECTED" : "ALL",
-                        orgUnit: orgUnitIds?.join(";"),
-                        fields: fields,
-                        program: programId,
-                        trackedEntity,
-                    })
-                    .getData();
+                log.debug(`GET ${model} (pageSize=${pageSize}, page=${page})`);
+
+                const apiOptions = {
+                    page,
+                    pageSize: pageSize,
+                    ouMode: orgUnitIds ? ("SELECTED" as const) : ("ALL" as const),
+                    orgUnit: orgUnitIds?.join(";"),
+                    fields: { $all: true as const },
+                    program: programId,
+                    trackedEntity,
+                };
+
+                const { tracker } = this.api;
+
+                const endpoint = {
+                    trackedEntities: () => tracker.trackedEntities.get(apiOptions),
+                    enrollments: () => tracker.enrollments.get(apiOptions),
+                    events: () => tracker.events.get(apiOptions),
+                };
+
+                const res = await endpoint[model]().getData();
+                const instances: Output = res.instances as Output;
 
                 if (instances.length === 0) {
                     dataRemaining = false;
@@ -96,16 +117,21 @@
                 }
             }
         }
-        log.info(`GET ${apiPath} -> Total: ${output.length}`);
+        log.info(`GET ${model} -> Total: ${output.length}`);
 
         return output;
     }
 }
 
 type TrackerResponse = {
     status: string;
-    typeReports: object[];
     stats: Stats;
 };
 
 type TrackerDataKey = "events" | "enrollments" | "trackedEntities";
+
+type Mapping = {
+    trackedEntities: TrackedEntitiesGetResponse<{ $all: true }>["instances"];
+    enrollments: TrackerEnrollmentsResponse<{ $all: true }>["instances"];
+    events: TrackerEventsResponse<{ $all: true }>["instances"];
+};