Merge pull request #481 from tidepool-org/WEB-3688-twiist-suppressed-basal-data

[WEB-3688] Generate suppressed basal data for twiist

Author: clintonium-119

data/types.js

@@ -95,6 +95,7 @@ export class Basal extends Common {
     this.deliveryType = opts.deliveryType;
     this.deviceTime = opts.deviceTime;
     this.duration = opts.duration;
+    this.origin = opts.origin;
     this.rate = opts.rate;
     this.scheduleName = opts.scheduleName;
     this.annotations = opts.annotations;
@@ -104,7 +105,9 @@ export class Basal extends Common {
 
     this.time = opts.time || this.makeTime();
     this.timezoneOffset = this.makeTimezoneOffset();
+    if (!opts.raw) this.time = Date.parse(this.time);
     if (!opts.raw) this.normalTime = this.makeNormalTime();
+    if (!opts.raw) this.deviceTime = Date.parse(this.deviceTime);
     if (!opts.raw) this.normalEnd = this.normalTime + this.duration;
   }
 }
@@ -229,7 +232,7 @@ export class Settings extends Common {
       },
     });
 
-    this.type = 'settings';
+    this.type = 'pumpSettings';
 
     this.activeSchedule = opts.activeSchedule;
     this.basalSchedules = opts.basalSchedules;
@@ -238,6 +241,7 @@ export class Settings extends Common {
     this.deviceTime = opts.deviceTime;
     this.insulinSensitivity = opts.insulinSensitivity;
     this.units = opts.units;
+    this.id = opts.id;
 
     this.time = this.makeTime();
     this.timezoneOffset = this.makeTimezoneOffset();
@@ -249,6 +253,7 @@ export class Settings extends Common {
       if (this.bgTarget.high) this.bgTarget.high = this.bgTarget.high / MGDL_PER_MMOLL;
     } else {
       this.normalTime = this.makeNormalTime();
+      this.time = Date.parse(this.time);
     }
   }
 }

package.json

@@ -4,7 +4,7 @@
     "node": "20.8.0"
   },
   "packageManager": "[email protected]",
-  "version": "1.46.0",
+  "version": "1.47.0-web-3688-twiist-suppressed-basal-data.2",
   "description": "Tidepool data visualization for diabetes device data.",
   "keywords": [
     "data visualization"

src/components/common/tooltips/Tooltip.css

@@ -23,6 +23,7 @@
   pointer-events: none;
   position: absolute;
   border-radius: 4px;
+  z-index: 1000;
 }
 
 .content {

src/utils/DataUtil.js

@@ -133,7 +133,12 @@ export class DataUtil {
     _.each(data, this.joinBolusAndDosingDecision);
     this.endTimer('joinBolusAndDosingDecision');
 
-    // Filter out any data that failed validation, and and duplicates by `id`
+    // Add missing suppressed basals to select basal datums
+    this.startTimer('addMissingSuppressedBasals');
+    this.addMissingSuppressedBasals(data);
+    this.endTimer('addMissingSuppressedBasals');
+
+    // Filter out any data that failed validation, and any duplicates by `id`
     this.startTimer('filterValidData');
     this.clearFilters();
     const validData = _.uniqBy(data, 'id');
@@ -337,6 +342,191 @@ export class DataUtil {
     }
   };
 
+  addMissingSuppressedBasals = data => {
+    // Mapping function to get the basal schedules for a given pumpSettings datum,
+    // ordered by start time in descending order for easier comparison with basals
+    const getOrderedPumpSettingsSchedules = ({ activeSchedule, basalSchedules, deviceId, time }) => ({
+      basalSchedule: _.orderBy(basalSchedules?.[activeSchedule], 'start', 'desc'),
+      time,
+      deviceId,
+    });
+
+    const shouldGenerateSuppressedBasal = (d) => (
+      d.type === 'basal' &&
+      !d.suppressed &&
+      _.includes(['automated', 'temp'], d.deliveryType) &&
+      isTwiistLoop(d)
+    );
+
+    // Get the pump settings datums ordered by start time in descending order
+    const pumpSettingsByStartTimes = _.orderBy(
+      _.map(_.values(this.pumpSettingsDatumsByIdMap), getOrderedPumpSettingsSchedules),
+      'time',
+      'desc'
+    );
+
+    // We will need add additional basals when we split existing basals that overlap with pump settings schedules
+    const basalsToAdd = [];
+
+    _.each(data, d => {
+      if (shouldGenerateSuppressedBasal(d)) {
+        // Get the pump settings datum that is active at the time of the basal by grabbing the first
+        // datum with a time less than or equal to the basal's time
+        const pumpSettingsDatum = _.find(pumpSettingsByStartTimes, ps => ps.deviceId === d.deviceId && ps.time <= d.time);
+        const activeSchedule = pumpSettingsDatum?.basalSchedule;
+
+        if (!activeSchedule?.length) {
+          // No schedule available, skip this basal
+          return;
+        }
+
+        // Calculate the end time of the basal
+        const basalEndTime = d.time + (d.duration || 0);
+
+        // Get the msPer24 for the utc start and end times of the basal datum, then adjust for timezone offset
+        const timezoneOffsetMs = (d.timezoneOffset || 0) * MS_IN_MIN;
+        const basalMsPer24WithOffset = {
+          start: getMsPer24(d.time) + timezoneOffsetMs,
+          end: getMsPer24(basalEndTime) + timezoneOffsetMs,
+        };
+
+        // If the offset msPer24 is negative, as can happen with negative timezone offsets,
+        // we need to add a day to adjust it to be within the 24-hour range
+        if (basalMsPer24WithOffset.start < 0) basalMsPer24WithOffset.start += MS_IN_DAY;
+        if (basalMsPer24WithOffset.end < 0) basalMsPer24WithOffset.end += MS_IN_DAY;
+
+        // If end time crosses midnight (is less than start), extend it to next day
+        if (basalMsPer24WithOffset.end < basalMsPer24WithOffset.start) {
+          basalMsPer24WithOffset.end += MS_IN_DAY;
+        }
+
+        // Find all schedule segments that this basal overlaps
+        const currentDaySegments = [];
+        const nextDaySegments = [];
+
+        // Sort schedule by start time ascending for easier processing
+        const sortedSchedule = _.sortBy(activeSchedule, 'start');
+
+        for (let i = 0; i < sortedSchedule.length; i++) {
+          const segment = sortedSchedule[i];
+          const nextSegment = sortedSchedule[i + 1];
+
+          const segmentStart = segment.start;
+          const segmentEnd = nextSegment ? nextSegment.start : MS_IN_DAY;
+
+          // Check if basal overlaps with this segment in the current day
+          const basalOverlapsCurrentDay = (
+            basalMsPer24WithOffset.start < segmentEnd &&
+            basalMsPer24WithOffset.end > segmentStart
+          );
+
+          if (basalOverlapsCurrentDay) {
+            currentDaySegments.push({
+              ...segment,
+              segmentEnd,
+              overlapStart: Math.max(basalMsPer24WithOffset.start, segmentStart),
+              overlapEnd: Math.min(basalMsPer24WithOffset.end, segmentEnd)
+            });
+          }
+
+          // Also check if basal overlaps with this segment when extended to next day
+          // This handles cases where the basal crosses midnight
+          if (basalMsPer24WithOffset.end > MS_IN_DAY) {
+            const extendedSegmentStart = segmentStart + MS_IN_DAY;
+            const extendedSegmentEnd = segmentEnd + MS_IN_DAY;
+
+            const basalOverlapsNextDay = (
+              basalMsPer24WithOffset.start < extendedSegmentEnd &&
+              basalMsPer24WithOffset.end > extendedSegmentStart
+            );
+
+            if (basalOverlapsNextDay) {
+              nextDaySegments.push({
+                ...segment,
+                segmentEnd: extendedSegmentEnd,
+                overlapStart: Math.max(basalMsPer24WithOffset.start, extendedSegmentStart),
+                overlapEnd: Math.min(basalMsPer24WithOffset.end, extendedSegmentEnd)
+              });
+            }
+          }
+        }
+
+        // Combine segments in chronological order: current day first, then next day
+        const overlappingSegments = [...currentDaySegments, ...nextDaySegments];
+
+        // It's expected that a basal will overlap with at least one segment
+        if (overlappingSegments.length === 1) {
+          // Simple case: basal is within a single schedule segment
+          const segment = overlappingSegments[0];
+          d.suppressed = {
+            ...d,
+            id: `${d.id}_suppressed`,
+            deliveryType: 'scheduled',
+            rate: segment.rate || 0,
+          };
+        } else if (overlappingSegments.length > 1) {
+          // Complex case: basal crosses schedule boundaries, need to split
+          const originalDuration = d.duration || 0;
+          const basalDurationMs24 = basalMsPer24WithOffset.end - basalMsPer24WithOffset.start;
+
+          // Update the original basal to cover only the first segment
+          const firstSegment = overlappingSegments[0];
+          const firstSegmentMs24Duration = firstSegment.overlapEnd - firstSegment.overlapStart;
+          const firstSegmentDuration = (firstSegmentMs24Duration / basalDurationMs24) * originalDuration;
+
+          d.duration = firstSegmentDuration;
+          d.suppressed = {
+            ...d,
+            id: `${d.id}_suppressed`,
+            deliveryType: 'scheduled',
+            rate: firstSegment.rate || 0,
+            duration: firstSegmentDuration,
+            time: d.time, // Keep original time
+          };
+
+          // Create additional basal datums for the remaining segments
+          let cumulativeDuration = firstSegmentDuration;
+
+          for (let i = 1; i < overlappingSegments.length; i++) {
+            const segment = overlappingSegments[i];
+            const segmentMs24Duration = segment.overlapEnd - segment.overlapStart;
+            const segmentDuration = (segmentMs24Duration / basalDurationMs24) * originalDuration;
+
+            const newBasal = {
+              ...d,
+              id: `${d.id}_split_${i}`,
+              time: d.time + cumulativeDuration,
+              duration: segmentDuration,
+              suppressed: {
+                ...d,
+                id: `${d.id}_suppressed_split_${i}`,
+                deliveryType: 'scheduled',
+                rate: segment.rate || 0,
+                duration: segmentDuration,
+                time: d.time + cumulativeDuration,
+              }
+            };
+
+            // Update deviceTime if it exists
+            if (d.deviceTime) {
+              newBasal.deviceTime = d.deviceTime + cumulativeDuration;
+              newBasal.suppressed.deviceTime = newBasal.deviceTime;
+            }
+
+            basalsToAdd.push(newBasal);
+            cumulativeDuration += segmentDuration;
+          }
+        } else {
+          // Fallback: no overlapping segments found (shouldn't happen normally)
+          this.log('Warning: No overlapping segments found for basal', d.id);
+        }
+      }
+    });
+
+    // Add the new split basal datums to the data array
+    data.push(...basalsToAdd);
+  };
+
   /**
    * Medtronic 5 and 7 series (which always have a deviceId starting with 'MedT-') carb exchange
    * data is converted to carbs at a rounded 1:15 ratio in the uploader, and needs to be