Added activity processing

Author: nora-soderlund

package-lock.json

@@ -8,6 +8,7 @@
     "author": "Nora Söderlund",
     "devDependencies": {
         "@cloudflare/workers-types": "^4.20230518.0",
+        "@ridetracker/ridetrackertypes": "^0.9.7",
         "@types/geolib": "^2.0.23",
         "@types/itty-router-extras": "^0.4.0",
         "@types/react": "^18.2.6",
@@ -16,6 +17,7 @@
         "wrangler": "^3.0.1"
     },
     "dependencies": {
+        "@googlemaps/polyline-codec": "^1.0.28",
         "@ridetracker/authservice": "^0.9.2",
         "@ridetracker/discordwebhooksclient": "^0.9.0",
         "geolib": "^3.3.4",

package.json

@@ -0,0 +1,5 @@
+import { Activity } from "@ridetracker/ridetrackertypes";
+
+export async function getActivityById(database: D1Database, id: string): Promise<Activity> {
+    return await database.prepare("SELECT start_area AS startArea, finish_area AS finishArea, local_id AS localId, activities.* FROM activities WHERE id = ?").bind(id).first<Activity>();
+};

src/controllers/activities/getActivityById.ts

@@ -0,0 +1,30 @@
+import { Recording } from "@ridetracker/ridetrackertypes";
+import getActivityRecordingFromArray from "./getActivityRecordingFromArray";
+
+export default async function getActivityRecording(bucket: R2Bucket, activityId: string): Promise<Recording | null> {
+    const response = await bucket.get(`/activities/${activityId}.json`);
+
+    if(!response)
+        return null;
+
+    const result: any = await response.json();
+
+    const version = (Array.isArray(result))?(1):(result.version);
+
+    // We do not, ever, want to rewrite the original upload file;
+    // instead, upgrade the recordings each time it has to be reprocessed;
+    // or if reason be, migrate processed recordings to a new bucket folder.
+
+    switch(version) {
+        // Version 1 is an array of sessions with coords objects.
+        case 1:
+            return getActivityRecordingFromArray(result);
+
+        // Version 2 is currently representated by the Recording type.
+        case 2:
+            return result;
+
+        default:
+            return null;
+    }
+};

src/controllers/activities/recordings/getActivityRecording.ts

@@ -0,0 +1,93 @@
+import { Recording, RecordingSession, RecordingSessionAltitude, RecordingSessionBatteryState, RecordingSessionCoordinate, RecordingSessionSpeed, RecordingV1Session, RecordingV1SessionBatteryState } from "@ridetracker/ridetrackertypes";
+
+export default function getActivityRecordingFromArray(sessions: RecordingV1Session[]): Recording | null {
+    if(!sessions.length)
+        return null;
+
+    const recording: Recording = {
+        // localId was implemented in RideTrackerApp-0.9.3
+        id: sessions[0].id,
+
+        version: 2,
+
+        sessions: sessions.map<RecordingSession>((session) => {
+            return {
+                id: session.id,
+
+                coordinates: session.locations.map<RecordingSessionCoordinate>((location) => {
+                    return {
+                        coordinate: {
+                            latitude: location.coords.latitude,
+                            longitude: location.coords.longitude
+                        },
+
+                        accuracy: location.coords.accuracy,
+                        timestamp: location.timestamp
+                    };
+                }),
+
+                altitudes: session.locations.map<RecordingSessionAltitude>((location) => {
+                    return {
+                        altitude: location.coords.altitude,
+                        accuracy: location.coords.altitudeAccuracy,
+                        timestamp: location.timestamp
+                    };
+                }),
+
+                batteryStates: (session.battery ?? []).map<RecordingSessionBatteryState>((battery) => {
+                    let batteryState: RecordingSessionBatteryState["batteryState"]["batteryState"] = "UNKNOWN";
+
+                    switch(battery.batteryState) {
+                        case RecordingV1SessionBatteryState.UNKNOWN: {
+                            batteryState = "UNKNOWN";
+
+                            break;
+                        };
+
+                        case RecordingV1SessionBatteryState.UNPLUGGED: {
+                            batteryState = "UNPLUGGED";
+
+                            break;
+                        };
+
+                        case RecordingV1SessionBatteryState.CHARGING: {
+                            batteryState = "CHARGING";
+
+                            break;
+                        };
+
+                        case RecordingV1SessionBatteryState.FULL: {
+                            batteryState = "FULL";
+
+                            break;
+                        };
+                    }
+
+                    return {
+                        batteryState: {
+                            batteryState,
+                            batteryLevel: battery.batteryLevel,
+                            lowPowerMode: battery.lowPowerMode
+                        },
+
+                        timestamp: battery.timestamp
+                    }
+                }),
+
+                speeds: session.locations.map<RecordingSessionSpeed>((location) => {
+                    return {
+                        speed: location.coords.speed,
+                        accuracy: location.coords.accuracy,
+                        timestamp: location.timestamp
+                    };
+                }),
+                
+                calories: [],
+                
+                heartRates: []
+            }
+        })
+    }
+
+    return recording;
+};

src/controllers/activities/recordings/getActivityRecordingFromArray.ts

@@ -0,0 +1,18 @@
+import { Recording } from "@ridetracker/ridetrackertypes";
+import { createActivitySummary } from "../../summaries/createActivitySummary";
+import { getDistance } from "geolib";
+
+export default async function processActivityRecordingDistanceSummary(env: Env, activityId: string, recording: Recording) {
+    let distance = 0;
+
+    recording.sessions.forEach((session) => {
+        if(session.coordinates.length < 2)
+            return;
+
+        for(let index = 1; index < session.coordinates.length; index++) {
+            distance += getDistance(session.coordinates[index - 1].coordinate, session.coordinates[index].coordinate, session.coordinates[index].accuracy);
+        }
+    });
+
+    await createActivitySummary(env.DATABASE, activityId, "distance", distance);
+};

src/controllers/activities/recordings/processing/processActivityRecordingDistanceSummary.ts

@@ -0,0 +1,17 @@
+import { Recording } from "@ridetracker/ridetrackertypes";
+import { createActivitySummary } from "../../summaries/createActivitySummary";
+
+export default async function processActivityRecordingElevationSummary(env: Env, activityId: string, recording: Recording) {
+    let elevation = 0;
+
+    recording.sessions.forEach((session) => {
+        if(session.altitudes.length < 2)
+            return;
+
+        for(let index = 1; index < session.altitudes.length; index++) {
+            elevation += Math.max(0, Math.min(session.altitudes[index].altitude - session.altitudes[index - 1].altitude, session.altitudes[index].accuracy));
+        }
+    });
+
+    await createActivitySummary(env.DATABASE, activityId, "elevation", elevation);
+};

src/controllers/activities/recordings/processing/processActivityRecordingElevationSummary.ts

@@ -0,0 +1,18 @@
+import { Recording, RecordingSessionCoordinate } from "@ridetracker/ridetrackertypes";
+import getMapsAreaFromCoordinates from "../../../maps/getMapsAreaFromCoordinates";
+import getRecordingLastItem from "../../../recordings/getRecordingLastItem";
+import { updateActivityFinishArea } from "../../updateActivityFinishArea";
+
+export default async function processActivityRecordingFinishArea(env: Env, activityId: string, recording: Recording) {
+    const lastCoordinate = getRecordingLastItem<RecordingSessionCoordinate>(recording, "coordinates");
+
+    if(!lastCoordinate) {
+        console.warn("Failed to find an initial coordinate.");
+
+        return;
+    }
+
+    const result = await getMapsAreaFromCoordinates(env.GOOGLE_MAPS_API_KEY, lastCoordinate.coordinate);
+
+    await updateActivityFinishArea(env.DATABASE, activityId, result);
+};

src/controllers/activities/recordings/processing/processActivityRecordingFinishArea.ts

@@ -0,0 +1,36 @@
+import { Recording, RecordingSessionCoordinate } from "@ridetracker/ridetrackertypes";
+import getRecordingFirstItem from "../../../recordings/getRecordingFirstItem";
+import getMapsAreaFromCoordinates from "../../../maps/getMapsAreaFromCoordinates";
+import { updateActivityStartArea } from "../../updateActivityStartArea";
+import { Coordinate } from "../../../../models/Coordinate";
+import { encode } from "@googlemaps/polyline-codec";
+import { getDistance } from "geolib";
+import { updateActivityPolylines } from "../../updateActivityPolylines";
+
+export default async function processActivityRecordingPolylines(env: Env, activityId: string, recording: Recording) {
+    const polylines: string[] = [];
+
+    recording.sessions.forEach((session) => {
+        const significantCoordinates: Coordinate[] = [];
+
+        if(session.coordinates.length >= 2) {
+            significantCoordinates.push(session.coordinates[0].coordinate);
+
+            let distance = 0;
+
+            for(let index = 1; index < session.coordinates.length - 1; index++) {
+                distance += getDistance(session.coordinates[index - 1].coordinate, session.coordinates[index].coordinate, session.coordinates[index].accuracy);
+
+                if(distance > 20)
+                    significantCoordinates.push(session.coordinates[index].coordinate);
+            }
+
+            if(session.coordinates.length > 2)
+                significantCoordinates.push(session.coordinates[session.coordinates.length - 1].coordinate);
+        }
+
+        polylines.push(encode(significantCoordinates.map((coordinate) => [ coordinate.latitude, coordinate.longitude ])));
+    });
+
+    updateActivityPolylines(env.DATABASE, activityId, JSON.stringify(polylines));
+};

src/controllers/activities/recordings/processing/processActivityRecordingPolylines.ts

@@ -0,0 +1,21 @@
+import { Recording } from "@ridetracker/ridetrackertypes";
+import { createActivitySummary } from "../../summaries/createActivitySummary";
+
+export default async function processActivityRecordingSpeedSummary(env: Env, activityId: string, recording: Recording) {
+    const speeds = recording.sessions.flatMap((session) => session.speeds);
+
+    const maxSpeed = speeds.reduce((highest, current) => {
+        if(current.speed > highest)
+            return current.speed;
+
+        return highest;
+    }, 0);
+
+    const speedSum = speeds.reduce((accumulated, current) => accumulated + current.speed, 0);
+    const averageSpeed = (speedSum / speeds.length) || 0;
+
+    await Promise.allSettled([
+        createActivitySummary(env.DATABASE, activityId, "average_speed", averageSpeed),
+        createActivitySummary(env.DATABASE, activityId, "max_speed", maxSpeed)
+    ]);
+};