Max Heart Rate - daily data provider

src/helpers/daily-data-providers/apple-health-heart-rate.ts

@@ -0,0 +1,113 @@
+import { add, endOfDay, formatISO, parseISO, startOfDay } from "date-fns";
+import queryAllDeviceData from "./query-all-device-data";
+import queryAllDeviceDataV2Aggregates from "../query-all-device-data-v2-aggregates";
+import { DeviceDataPointQuery, DeviceDataV2AggregateQuery } from "@careevolution/mydatahelps-js/types";
+
+export function maxHeartRate (startDate: Date, endDate: Date): Promise<{ [key: string]: number }> {
+	const v2params: DeviceDataV2AggregateQuery = {
+        namespace: 'AppleHealth',
+        type: 'Heart Rate',
+        observedAfter: startOfDay(startDate).toISOString(),
+        observedBefore: endOfDay(endDate).toISOString(),
+        intervalAmount: 1,
+        intervalType: 'Days',
+        aggregateFunctions: ['max']
+    };
+
+	const v1params: DeviceDataPointQuery = {
+		namespace: "AppleHealth",
+		type: "HourlyMaximumHeartRate",
+		observedAfter: add(startDate, { days: -1 }).toISOString(),
+		observedBefore: add(endDate, { days: 1 }).toISOString()
+	}
+
+    return Promise.allSettled([ queryAllDeviceDataV2Aggregates(v2params), queryAllDeviceData(v1params) ]).then(queryResults => {
+		var data: { [key: string]: number } = {};
+		if (queryResults[0].status === 'fulfilled') {
+			queryResults[0].value.forEach((aggregate) => {
+				data[formatISO(parseISO(aggregate.date)).substring(0, 10)] = aggregate.statistics['max'];
+			});
+		}
+		if (queryResults[1].status === 'fulfilled') {
+			queryResults[1].value.forEach((d) => {
+				if (!d.startDate) { return; }
+				var day = formatISO(parseISO(d.startDate)).substring(0, 10);
+				var value = parseFloat(d.value);
+				if (!data[day]) {
+					data[day] = value;
+				} else if (value > data[day]) {
+					data[day] = value;
+				}
+			});
+		}
+		return data;
+
+    }, () => ({} as { [key: string]: number }));
+}
+
+export function minHeartRate (startDate: Date, endDate: Date): Promise<{ [key: string]: number }> {
+	const v2params: DeviceDataV2AggregateQuery = {
+        namespace: 'AppleHealth',
+        type: 'Heart Rate',
+        observedAfter: startOfDay(startDate).toISOString(),
+        observedBefore: endOfDay(endDate).toISOString(),
+        intervalAmount: 1,
+        intervalType: 'Days',
+        aggregateFunctions: ['min']
+    };
+
+	const v1params: DeviceDataPointQuery = {
+		namespace: "AppleHealth",
+		type: "HourlyMinimumHeartRate",
+		observedAfter: add(startDate, { days: -1 }).toISOString(),
+		observedBefore: add(endDate, { days: 1 }).toISOString()
+	}
+
+    return Promise.allSettled([ queryAllDeviceDataV2Aggregates(v2params), queryAllDeviceData(v1params) ]).then(queryResults => {
+		var data: { [key: string]: number } = {};
+		if (queryResults[0].status === 'fulfilled') {
+			queryResults[0].value.forEach((aggregate) => {
+				data[formatISO(parseISO(aggregate.date)).substring(0, 10)] = aggregate.statistics['min'];
+			});
+		}
+		if (queryResults[1].status === 'fulfilled') {
+			queryResults[1].value.forEach((d) => {
+				if (!d.startDate) { return; }
+				var day = formatISO(parseISO(d.startDate)).substring(0, 10);
+				var value = parseFloat(d.value);
+				if (!data[day]) {
+					data[day] = value;
+				} else if (value < data[day] && value > 0) {
+					data[day] = value;
+				}
+			});
+		}
+		return data;
+
+    }, () => ({} as { [key: string]: number }));
+}
+
+export function averageHeartRate (startDate: Date, endDate: Date): Promise<{ [key: string]: number }> {
+	const v2params: DeviceDataV2AggregateQuery = {
+        namespace: 'AppleHealth',
+        type: 'Heart Rate',
+        observedAfter: startOfDay(startDate).toISOString(),
+        observedBefore: endOfDay(endDate).toISOString(),
+        intervalAmount: 1,
+        intervalType: 'Days',
+        aggregateFunctions: ['average']
+    };
+
+    return Promise.allSettled([ queryAllDeviceDataV2Aggregates(v2params) ]).then(queryResults => {
+		var data: { [key: string]: number } = {};
+		if (queryResults[0].status === 'fulfilled') {
+			queryResults[0].value.forEach((aggregate) => {
+				data[formatISO(parseISO(aggregate.date)).substring(0, 10)] = aggregate.statistics['average'];
+			});
+		}
+
+		return data;
+
+    }, () => ({} as { [key: string]: number }));
+}
+

src/helpers/daily-data-providers/fitbit-heart-rate.ts

@@ -0,0 +1,76 @@
+import { add, endOfDay, formatISO, parseISO, startOfDay } from "date-fns";
+import queryAllDeviceDataV2Aggregates from "../query-all-device-data-v2-aggregates";
+import { DeviceDataV2AggregateQuery } from "@careevolution/mydatahelps-js/types";
+
+export function fitbitMaxHeartRate (startDate: Date, endDate: Date): Promise<{ [key: string]: number }> {
+	const v2params: DeviceDataV2AggregateQuery = {
+        namespace: 'Fitbit',
+        type: 'activities-heart-intraday',
+        observedAfter: startOfDay(startDate).toISOString(),
+        observedBefore: endOfDay(endDate).toISOString(),
+        intervalAmount: 1,
+        intervalType: 'Days',
+        aggregateFunctions: ['max']
+    };
+
+    return Promise.allSettled([ queryAllDeviceDataV2Aggregates(v2params) ]).then(queryResults => {
+		var data: { [key: string]: number } = {};
+		if (queryResults[0].status === 'fulfilled') {
+			queryResults[0].value.forEach((aggregate) => {
+				data[formatISO(parseISO(aggregate.date)).substring(0, 10)] = aggregate.statistics['max'];
+			});
+		}
+
+		return data;
+
+    }, () => ({} as { [key: string]: number }));
+}
+
+export function fitbitMinHeartRate (startDate: Date, endDate: Date): Promise<{ [key: string]: number }> {
+	const v2params: DeviceDataV2AggregateQuery = {
+        namespace: 'Fitbit',
+        type: 'activities-heart-intraday',
+        observedAfter: startOfDay(startDate).toISOString(),
+        observedBefore: endOfDay(endDate).toISOString(),
+        intervalAmount: 1,
+        intervalType: 'Days',
+        aggregateFunctions: ['min']
+    };
+
+    return Promise.allSettled([ queryAllDeviceDataV2Aggregates(v2params) ]).then(queryResults => {
+		var data: { [key: string]: number } = {};
+		if (queryResults[0].status === 'fulfilled') {
+			queryResults[0].value.forEach((aggregate) => {
+				data[formatISO(parseISO(aggregate.date)).substring(0, 10)] = aggregate.statistics['min'];
+			});
+		}
+
+		return data;
+
+    }, () => ({} as { [key: string]: number }));
+}
+
+export function fitbitAverageHeartRate (startDate: Date, endDate: Date): Promise<{ [key: string]: number }> {
+	const v2params: DeviceDataV2AggregateQuery = {
+        namespace: 'Fitbit',
+        type: 'activities-heart-intraday',
+        observedAfter: startOfDay(startDate).toISOString(),
+        observedBefore: endOfDay(endDate).toISOString(),
+        intervalAmount: 1,
+        intervalType: 'Days',
+        aggregateFunctions: ['average']
+    };
+
+    return Promise.allSettled([ queryAllDeviceDataV2Aggregates(v2params) ]).then(queryResults => {
+		var data: { [key: string]: number } = {};
+		if (queryResults[0].status === 'fulfilled') {
+			queryResults[0].value.forEach((aggregate) => {
+				data[formatISO(parseISO(aggregate.date)).substring(0, 10)] = aggregate.statistics['average'];
+			});
+		}
+
+		return data;
+
+    }, () => ({} as { [key: string]: number }));
+}
+

src/helpers/daily-data-providers/index.ts

@@ -1,7 +1,9 @@
 export { default as appleHealthFlightsClimbedDataProvider } from "./apple-health-flights-climbed"
 export { default as appleHealthHrvDataProvider } from "./apple-health-hrv"
 export { default as appleHealthHeartRateRangeDataProvider } from "./apple-health-heart-rate-range"
-export { default as appleHealthMaxHeartRateDataProvider } from "./apple-health-max-heart-rate"
+export { maxHeartRate as appleHealthMaxHeartRateDataProvider } from "./apple-health-heart-rate"
+export { minHeartRate as appleHealthMinHeartRateDataProvider } from "./apple-health-heart-rate"
+export { averageHeartRate as appleHealthAverageHeartRateDataProvider } from "./apple-health-heart-rate"
 export { default as appleHealthRestingHeartRateDataProvider } from "./apple-health-resting-heart-rate"
 export { asleepTime as appleHealthSleepDataProvider } from "./apple-health-sleep"
 export { asleepRemTime as appleHealthSleepRemDataProvider } from "./apple-health-sleep"

src/helpers/daily-data-types.tsx

@@ -7,6 +7,8 @@ export enum DailyDataType {
 	AppleHealthHeartRateRange = "AppleHealthHeartRateRange",
 	AppleHealthHrv = "AppleHealthHrv",
 	AppleHealthMaxHeartRate = "AppleHealthMaxHeartRate",
+	AppleHealthMinHeartRate = "AppleHealthMinHeartRate",
+	AppleHealthAverageHeartRate = "AppleHealthAverageHeartRate",
 	AppleHealthRestingHeartRate = "AppleHealthRestingHeartRate",
 	AppleHealthSleepMinutes = "AppleHealthSleepMinutes",
 	AppleHealthRemSleepMinutes = "AppleHealthSleepRemMinutes",
@@ -32,6 +34,9 @@ export enum DailyDataType {
 	FitbitFloors = "FitbitFloors",
 	FitbitHrv = "FitbitHrv",
 	FitbitRestingHeartRate = "FitbitRestingHeartRate",
+	FitbitMaxHeartRate = "FitbitMaxHeartRate",
+	FitbitMinHeartRate = "FitbitMinHeartRate",
+	FitbitAverageHearthRate = "FitbitAverageHearthRate",
 	FitbitSleepMinutes = "FitbitSleepMinutes",
 	FitbitLightSleepMinutes = "FitbitLightSleepMinutes",
 	FitbitRemSleepMinutes = "FitbitRemSleepMinutes",
@@ -65,6 +70,9 @@ export enum DailyDataType {
 	GoogleFitSteps = "GoogleFitSteps",
 	Steps = "Steps",
 	RestingHeartRate = "RestingHeartRate",
+	MinHeartRate = "MinHeartRate",
+	MaxHeartRate = "MaxHeartRate",
+	AverageHeartRate = "AverageHeartRate",
 	SleepMinutes = "SleepMinutes",
 	HomeAirQuality = "HomeAirQuality",
 	WorkAirQuality = "WorkAirQuality"

src/helpers/daily-data-types/availability-check.ts

@@ -1,6 +1,6 @@
-import MyDataHelps, { DeviceDataNamespace, DeviceDataPointQuery } from "@careevolution/mydatahelps-js";
+import MyDataHelps, { DeviceDataNamespace, DeviceDataPointQuery, DeviceDataV2AggregateQuery, DeviceDataV2Namespace, DeviceDataV2Query } from "@careevolution/mydatahelps-js";
 
-export function simpleAvailabilityCheck(namespace: DeviceDataNamespace, type: string | string[]) {
+export function simpleAvailabilityCheck(namespace: DeviceDataNamespace, type: string | string[]): (modifiedAfter?: Date) => Promise<boolean> {
 	return function (modifiedAfter?: Date) {
 		var parameters: DeviceDataPointQuery = { namespace: namespace, type: type, limit: 1 };
 		if (modifiedAfter) {
@@ -12,4 +12,71 @@ export function simpleAvailabilityCheck(namespace: DeviceDataNamespace, type: st
 			return false;
 		});
 	}
-}
+}
+
+// todo: test
+export function simpleAvailabilityCheckV2(namespace: DeviceDataV2Namespace, type: string): (modifiedAfter?: Date) => Promise<boolean> {
+	return function (modifiedAfter?: Date) {
+		var parameters: DeviceDataV2Query = { 
+			namespace: namespace, 
+			type: type, 
+			limit: 1 
+		};
+		if (modifiedAfter) {
+			parameters.modifiedAfter = modifiedAfter.toISOString();
+		}
+
+		return MyDataHelps.queryDeviceDataV2(parameters).then(function (result) {
+			return result.deviceDataPoints.length > 0;
+		}).catch(function () {
+			return false;
+		});
+	}
+}
+
+// todo: test
+export function simpleAvailabilityCheckV2Aggregate(namespace: DeviceDataV2Namespace, type: string, aggregateFunctions: string | string[]): (modifiedAfter?: Date) => Promise<boolean> {
+	return function (modifiedAfter?: Date) {
+		var parameters: DeviceDataV2AggregateQuery = { 
+			namespace: namespace, 
+			type: type, 
+			limit: 1,
+			intervalAmount: 1,
+			intervalType: "Days",
+			aggregateFunctions: aggregateFunctions
+		};
+		if (modifiedAfter) {
+			parameters.modifiedAfter = modifiedAfter.toISOString();
+		}
+
+		return MyDataHelps.queryDeviceDataV2Aggregate(parameters).then(function (result) {
+			return result.intervals.length > 0;
+		}).catch(function () {
+			return false;
+		});
+	}
+}
+
+export function combinedAvailabilityCheck(
+			parameters?: { namespace: DeviceDataNamespace, type: string | string[] }[], 
+			v2AggregateParameters?: { namespace: DeviceDataV2Namespace, type: string, aggregateFunctions: string | string[] }[],
+			v2Parameters?: { namespace: DeviceDataV2Namespace, type: string }[]): (modifiedAfter?: Date) => Promise<boolean> {
+	return function(modifiedAfter?: Date) {
+		var checks: any[] = [];
+		if (parameters) {
+			checks.concat( parameters.map(param => simpleAvailabilityCheck(param.namespace, param.type)) );
+		} 
+		if (v2AggregateParameters) {
+			checks.concat( v2AggregateParameters.map(param => simpleAvailabilityCheckV2Aggregate(param.namespace, param.type, param.aggregateFunctions)) );
+		}
+		if (v2Parameters) {
+			checks.concat( v2Parameters.map(param => simpleAvailabilityCheckV2(param.namespace, param.type)) );
+		}
+
+		return Promise.allSettled(checks.map(check => check(modifiedAfter))).then(function (results) {
+			return results.some(result => result.status === 'fulfilled' && result.value === true); 
+		});
+	}
+};
+
+