/// <summary> /// Add subscription /// </summary> /// <param name="apiCollectionType"></param> /// <param name="uniqueSubscriptionId"></param> /// <param name="subscriberId"></param> /// <returns></returns> public async Task <FitbitResponse <ApiSubscription> > AddSubscriptionAsync(APICollectionType apiCollectionType, string uniqueSubscriptionId, string subscriberId = default(string)) { string path = FormatKey(apiCollectionType, Constants.Formatting.TrailingSlash); string resource = FormatKey(apiCollectionType, Constants.Formatting.LeadingDash); string url = "/1/user/-/{1}apiSubscriptions/{3}{2}.json"; string apiCall = FitbitClientHelperExtensions.ToFullUrl(url, args: new object[] { path, resource, uniqueSubscriptionId }); if (!string.IsNullOrWhiteSpace(subscriberId)) { HttpClient.DefaultRequestHeaders.Add(Constants.Headers.XFitbitSubscriberId, subscriberId); } HttpResponseMessage response = await HttpClient.PostAsync(apiCall, new StringContent(string.Empty)); var fitbitResponse = await HandleResponse <ApiSubscription>(response); if (fitbitResponse.Success) { var responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer(); fitbitResponse.Data = serializer.Deserialize <ApiSubscription>(responseBody); } return(fitbitResponse); }
/// <summary> /// Logs the specified WaterLog item for the current logged in user - https://wiki.fitbit.com/display/API/API-Log-Water /// </summary> /// <param name="date"></param> /// <param name="log"></param> /// <returns></returns> public async Task <FitbitResponse <WaterLog> > LogWaterAsync(DateTime date, WaterLog log) { string apiCall = FitbitClientHelperExtensions.ToFullUrl("/1/user/-/foods/log/water.json"); var items = new Dictionary <string, string>(); items.Add("amount", log.Amount.ToString()); items.Add("date", date.ToFitbitFormat()); apiCall = string.Format("{0}?{1}", apiCall, string.Join("&", items.Select(x => string.Format("{0}={1}", x.Key, x.Value)))); HttpResponseMessage response = await HttpClient.PostAsync(apiCall, new StringContent(string.Empty)); var fitbitResponse = await HandleResponse <WaterLog>(response); if (fitbitResponse.Success) { string responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer { RootProperty = "waterLog" }; fitbitResponse.Data = serializer.Deserialize <WaterLog>(responseBody); } return(fitbitResponse); }
/// <summary> /// GetTimeSeriesDataList has to do some custom manipulation with the returned representation /// </summary> /// <param name="serializer"></param> /// <param name="timeSeriesDataJson"></param> /// <returns></returns> internal static HeartActivitiesIntraday GetHeartRateIntraday(this JsonDotNetSerializer serializer, DateTime date, string heartRateIntradayJson) { if (string.IsNullOrWhiteSpace(heartRateIntradayJson)) { throw new ArgumentNullException("heartRateIntradayJson", "heartRateIntradayJson can not be empty, null or whitespace."); } JToken activitiesHeartIntraday = JToken.Parse(heartRateIntradayJson)["activities-heart-intraday"]; JToken dataset = activitiesHeartIntraday["dataset"]; HeartActivitiesIntraday result = new HeartActivitiesIntraday { ActivitiesHeart = serializer.Deserialize <IntradayActivitiesHeart>(JToken.Parse(heartRateIntradayJson)["activities-heart"].First()), Dataset = (from item in dataset select new DatasetInterval { Time = DateTime.Parse(date.ToString("yyyy-MM-dd") + " " + item["time"].ToString()), //here, maybe pass in the date so we have a full object of date and time Value = int.Parse(item["value"].ToString()) }).ToList(), DatasetInterval = Convert.ToInt32(activitiesHeartIntraday["datasetInterval"]), DatasetType = activitiesHeartIntraday["datasetType"].ToString() }; return(result); }
/// <summary> /// Set the Goals for the current logged in user; individual goals, multiple or all can be specified in one call.</summary> /// <param name="caloriesOut"></param> /// <param name="distance"></param> /// <param name="floors"></param> /// <param name="steps"></param> /// <param name="activeMinutes"></param> /// <returns></returns> public async Task <FitbitResponse <ActivityGoals> > SetGoalsAsync(int caloriesOut = default(int), decimal distance = default(decimal), int floors = default(int), int steps = default(int), int activeMinutes = default(int)) { // parameter checking; at least one needs to be specified if ((caloriesOut == default(int)) && (distance == default(decimal)) && (floors == default(int)) && (steps == default(int)) && (activeMinutes == default(int))) { throw new ArgumentException("Unable to call SetGoalsAsync without specifying at least one goal parameter to set."); } var messageContentParameters = new Dictionary <string, string>(); if (caloriesOut != default(int)) { messageContentParameters.Add("caloriesOut", caloriesOut.ToString()); } if (distance != default(decimal)) { messageContentParameters.Add("distance", distance.ToString()); } if (floors != default(int)) { messageContentParameters.Add("floors", floors.ToString()); } if (steps != default(int)) { messageContentParameters.Add("steps", steps.ToString()); } if (activeMinutes != default(int)) { messageContentParameters.Add("activeMinutes", activeMinutes.ToString()); } var apiCall = FitbitClientHelperExtensions.ToFullUrl("/1/user/-/activities/goals/daily.json"); //caloriesOut=100&distance=1.0&floors=1&steps=8000&activeMinutes=10 HttpResponseMessage response = await HttpClient.PostAsync(apiCall, new FormUrlEncodedContent(messageContentParameters)); var fitbitResponse = await HandleResponse <ActivityGoals>(response); if (fitbitResponse.Success) { string responseBody = await response.Content.ReadAsStringAsync(); var seralizer = new JsonDotNetSerializer { RootProperty = "goals" }; fitbitResponse.Data = seralizer.Deserialize <ActivityGoals>(responseBody); } return(fitbitResponse); }
/// <summary> /// Parses the error structure which is common when errors are raised from the api /// </summary> /// <param name="serializer"></param> /// <param name="errorJson"></param> /// <returns></returns> internal static List <ApiError> ParseErrors(this JsonDotNetSerializer serializer, string errorJson) { if (string.IsNullOrWhiteSpace(errorJson)) { throw new ArgumentNullException(nameof(errorJson), "errorJson can not be empty, null or whitespace"); } serializer.RootProperty = "errors"; return(serializer.Deserialize <List <ApiError> >(errorJson)); }
/// <summary> /// The Get Sleep Logs List endpoint returns a list of a user's sleep logs (including naps) /// before or after a given day with offset, limit, and sort order. /// </summary> /// <param name="dateToList"> The date in the format yyyy-MM-ddTHH:mm:ss. Only yyyy-MM-dd is required. Set sort to desc when using beforeDate.</param> /// <param name="decisionDate"></param> /// <param name="sort">The sort order of entries by date. Required. asc for ascending, desc for descending</param> /// <param name="limit">The max of the number of sleep logs returned. Required.</param> /// <param name="encodedUserId"></param> /// <returns></returns> public async Task <SleepLogListBase> GetSleepLogListAsync(DateTime dateToList, SleepEnum decisionDate, SortEnum sort, int limit, string encodedUserId = null) { string setSleepDecision, setSort; //decide if date retrieval is before or after switch (decisionDate) { case SleepEnum.After: setSleepDecision = "afterDate"; break; case SleepEnum.Before: setSleepDecision = "beforeDate"; break; default: //in case of some sort of error we will set our date to before setSleepDecision = "beforeDate"; break; } //decide if we are sorting asc or dsc switch (sort) { case SortEnum.Asc: setSort = "asc"; break; case SortEnum.Dsc: setSort = "desc"; break; default: //in case of some sort of error we will set our sort to asc setSort = "asc"; break; } var apiCall = FitbitClientHelperExtensions.ToFullUrl("/1.2/user/{0}/sleep/list.json?{1}={2}&sort={3}&offset=0&limit={4}", encodedUserId, setSleepDecision, dateToList.ToFitbitFormat(), setSort, limit); HttpResponseMessage respone = await HttpClient.GetAsync(apiCall); await HandleResponse(respone); string responseBody = await respone.Content.ReadAsStringAsync(); var serialzer = new JsonDotNetSerializer(); var data = serialzer.Deserialize <SleepLogListBase>(responseBody); return(data); }
/// <summary> /// Get the set body measurements for the date value and user specified /// </summary> /// <param name="date"></param> /// <param name="encodedUserId"></param> /// <returns></returns> public async Task <BodyMeasurements> GetBodyMeasurementsAsync(DateTime date, string encodedUserId = default(string)) { string apiCall = FitbitClientHelperExtensions.ToFullUrl("/1/user/{0}/body/date/{1}.json", encodedUserId, date.ToFitbitFormat()); HttpResponseMessage response = await HttpClient.GetAsync(apiCall); await HandleResponse(response); string responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer(); return(serializer.Deserialize <BodyMeasurements>(responseBody)); }
/// <summary> /// Requests the lifetime activity details of the encoded user id or none supplied the current logged in user /// </summary> /// <param name="encodedUserId">encoded user id, can be null for current logged in user</param> /// <returns></returns> public async Task <ActivitiesStats> GetActivitiesStatsAsync(string encodedUserId = null) { string apiCall = FitbitClientHelperExtensions.ToFullUrl("/1/user/{0}/activities.json", encodedUserId); HttpResponseMessage response = await HttpClient.GetAsync(apiCall); await HandleResponse(response); string responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer(); return(serializer.Deserialize <ActivitiesStats>(responseBody)); }
/// <summary> /// Requests the devices for the current logged in user /// </summary> /// <returns>List of <see cref="Device"/></returns> public async Task <List <Device> > GetDevicesAsync() { var apiCall = FitbitClientHelperExtensions.ToFullUrl("/1/user/-/devices.json"); HttpResponseMessage response = await HttpClient.GetAsync(apiCall); await HandleResponse(response); string responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer(); return(serializer.Deserialize <List <Device> >(responseBody)); }
/// <summary> /// Requests the activity details of the encoded user id or if none supplied the current logged in user for the specified date /// </summary> /// <param name="activityDate"></param> /// <param name="encodedUserId">encoded user id, can be null for current logged in user</param> /// <returns>FitbitResponse of <see cref="ActivitySummary"/></returns> public async Task <Activity> GetDayActivityAsync(DateTime activityDate, string encodedUserId = null) { string apiCall = FitbitClientHelperExtensions.ToFullUrl("/1/user/{0}/activities/date/{1}.json", encodedUserId, activityDate.ToFitbitFormat()); HttpResponseMessage response = await HttpClient.GetAsync(apiCall); await HandleResponse(response); string responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer(); return(serializer.Deserialize <Activity>(responseBody)); }
/// <summary> /// Gets the water date for the specified date - https://wiki.fitbit.com/display/API/API-Get-Water /// </summary> /// <remarks> /// GET https://api.fitbit.com/1/user/-/foods/log/water/date/yyyy-mm-dd.json /// </remarks> /// <param name="date"></param> /// <returns></returns> public async Task <WaterData> GetWaterAsync(DateTime date) { string apiCall = FitbitClientHelperExtensions.ToFullUrl("/1/user/{0}/foods/log/water/date/{1}.json", args: date.ToFitbitFormat()); HttpResponseMessage response = await HttpClient.GetAsync(apiCall); await HandleResponse(response); string responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer(); return(serializer.Deserialize <WaterData>(responseBody)); }
internal static HeartActivitiesTimeSeries GetHeartActivitiesTimeSeries(this JsonDotNetSerializer serializer, string heartActivitiesTimeSeries) { if (string.IsNullOrWhiteSpace(heartActivitiesTimeSeries)) { throw new ArgumentNullException("heartActivitiesTimeSeries", "heartActivitiesTimeSeries can not be empty, null or whitespace."); } var activitiesHeartIntraday = JToken.Parse(heartActivitiesTimeSeries)["activities-heart"]; //var dataset = activitiesHeartIntraday["dataset"]; var result = new HeartActivitiesTimeSeries() { HeartActivities = (from item in activitiesHeartIntraday select new HeartActivities { DateTime = DateTime.Parse(item["dateTime"].ToString()), //here, maybe pass in the date so we have a full object of date and time HeartRateZones = serializer.Deserialize <List <HeartRateZone> >(item["value"]["heartRateZones"]), CustomHeartRateZones = serializer.Deserialize <List <HeartRateZone> >(item["value"]["customHeartRateZones"]) }).ToList(), }; return(result); }
/// <summary> /// Gets a list of the current subscriptions for the current logged in user /// </summary> /// <returns></returns> public async Task <List <ApiSubscription> > GetSubscriptionsAsync() { string apiCall = FitbitClientHelperExtensions.ToFullUrl("/1/user/-/apiSubscriptions.json"); HttpResponseMessage response = await HttpClient.GetAsync(apiCall); await HandleResponse(response); string responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer { RootProperty = "apiSubscriptions" }; return(serializer.Deserialize <List <ApiSubscription> >(responseBody)); }
/// <summary> /// Requests the sleep data for a specified date range for the logged in user /// </summary> /// <param name="endDate"></param> /// <param name="encodedUserId"></param> /// <param name="startDate"></param> /// <returns></returns> public async Task <SleepDateRangeBase> GetSleepDateRangeAsync(DateTime startDate, DateTime endDate, string encodedUserId = null) { var apiCall = FitbitClientHelperExtensions.ToFullUrl("/1.2/user/{0}/sleep/date/{1}/{2}.json", encodedUserId, startDate.ToFitbitFormat(), endDate.ToFitbitFormat()); HttpResponseMessage response = await HttpClient.GetAsync(apiCall); await HandleResponse(response); string responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer(); var data = serializer.Deserialize <SleepDateRangeBase>(responseBody); return(data); }
/// <summary> /// Requests the sleep data for the specified date for the logged in user /// NOTE: This is for the V1 of the sleep api which is now Deprecated /// </summary> /// <param name="sleepDate"></param> /// <returns></returns> public async Task <SleepData> GetSleepAsync(DateTime sleepDate) { string apiCall = FitbitClientHelperExtensions.ToFullUrl("/1/user/{0}/sleep/date/{1}.json", args: sleepDate.ToFitbitFormat()); HttpResponseMessage response = await HttpClient.GetAsync(apiCall); await HandleResponse(response); string responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer(); var data = serializer.Deserialize <SleepData>(responseBody); FitbitClientExtensions.ProcessSleepData(data); return(data); }
/// <summary> /// Creates a log entry for a sleep event and returns a response in the format requested /// </summary> /// <param name="startTime">Start time; hours and minutes in the format HH:mm. </param> /// <param name="duration">Duration in milliseconds.</param> /// <param name="date">Log entry date in the format yyyy-MM-dd. </param> /// <param name="encodedUserId"></param> /// <returns></returns> public async Task <SleepLogDateRange> PostLogSleepAsync(string startTime, int duration, DateTime date, string encodedUserId = null) { var apiCall = FitbitClientHelperExtensions.ToFullUrl("/1.2/user/{0}/sleep.json?date={1}&startTime={2}&duration={3}", encodedUserId, date.ToFitbitFormat(), startTime, duration); HttpResponseMessage respone = await HttpClient.PostAsync(apiCall, new StringContent(string.Empty)); await HandleResponse(respone); string responeBody = await respone.Content.ReadAsStringAsync(); var serialzer = new JsonDotNetSerializer(); return(serialzer.Deserialize <SleepLogDateRange>(responeBody)); }
/// <summary> /// Requests the user profile of the encoded user id or if none specified the current logged in user /// </summary> /// <param name="encodedUserId"></param> /// <returns><see cref="UserProfile"/></returns> public async Task <UserProfile> GetUserProfileAsync(string encodedUserId = default(string)) { string apiCall = FitbitClientHelperExtensions.ToFullUrl("/1/user/{0}/profile.json", encodedUserId); HttpResponseMessage response = await HttpClient.GetAsync(apiCall); await HandleResponse(response); string responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer { RootProperty = "user" }; return(serializer.Deserialize <UserProfile>(responseBody)); }
/// <summary> /// Get blood pressure data for date value and user specified /// </summary> /// <param name="date"></param> /// <param name="encodedUserId"></param> /// <returns></returns> public async Task <FitbitResponse <BloodPressureData> > GetBloodPressureAsync(DateTime date, string encodedUserId = default(string)) { string apiCall = FitbitClientHelperExtensions.ToFullUrl("/1/user/{0}/bp/date/{1}.json", encodedUserId, date.ToFitbitFormat()); HttpResponseMessage response = await HttpClient.GetAsync(apiCall); var fitbitResponse = await HandleResponse <BloodPressureData>(response); if (fitbitResponse.Success) { string responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer(); fitbitResponse.Data = serializer.Deserialize <BloodPressureData>(responseBody); } return(fitbitResponse); }
/// <summary> /// Requests the activity summary of the encoded user id or if none supplied the current logged in user for the specified date /// </summary> /// <param name="activityDate"></param> /// <param name="encodedUserId">encoded user id, can be null for current logged in user</param> /// <returns>FitbitResponse of <see cref="ActivitySummary"/></returns> public async Task <FitbitResponse <ActivitySummary> > GetDayActivitySummaryAsync(DateTime activityDate, string encodedUserId = null) { string apiCall = FitbitClientHelperExtensions.ToFullUrl("/1/user/{0}/activities/date/{1}.json", encodedUserId, activityDate.ToFitbitFormat()); HttpResponseMessage response = await HttpClient.GetAsync(apiCall); var fitbitResponse = await HandleResponse <ActivitySummary>(response); if (fitbitResponse.Success) { string responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer { RootProperty = "summary" }; fitbitResponse.Data = serializer.Deserialize <ActivitySummary>(responseBody); } return(fitbitResponse); }
/// <summary> /// General error checking of the response before specific processing is done. /// </summary> /// <param name="response"></param> private async Task <FitbitResponse <T> > HandleResponse <T>(HttpResponseMessage response) where T : class { var errors = new List <ApiError>(); if (!response.IsSuccessStatusCode) { try { var serializer = new JsonDotNetSerializer { RootProperty = "errors" }; errors.AddRange(serializer.Deserialize <List <ApiError> >(await response.Content.ReadAsStringAsync())); } catch { // if there is an error with the serialization then we need to default the errors back to an instantiated list errors = new List <ApiError>(); } } // todo: handle "success" responses which return errors? return(new FitbitResponse <T>(response.StatusCode, response.Headers, errors)); }