/// <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 <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)); await HandleResponse(response); string responseBody = await response.Content.ReadAsStringAsync(); var seralizer = new JsonDotNetSerializer { RootProperty = "goals" }; return(seralizer.Deserialize <ActivityGoals>(responseBody)); }
/// <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)); }
public async Task <IntradayData> GetIntraDayTimeSeriesAsync(IntradayResourceType timeSeriesResourceType, DateTime dayAndStartTime, TimeSpan intraDayTimeSpan) { string apiCall; if (intraDayTimeSpan > new TimeSpan(0, 1, 0) && //the timespan is greater than a minute dayAndStartTime.Day == dayAndStartTime.Add(intraDayTimeSpan).Day) //adding the timespan doesn't go in to the next day { apiCall = string.Format("/1/user/-{0}/date/{1}/1d/time/{2}/{3}.json", timeSeriesResourceType.GetStringValue(), dayAndStartTime.ToFitbitFormat(), dayAndStartTime.ToString("HH:mm"), dayAndStartTime.Add(intraDayTimeSpan).ToString("HH:mm")); } else //just get the today data, there was a date specified but the timerange was likely too large or negative { apiCall = string.Format("/1/user/-{0}/date/{1}/1d.json", timeSeriesResourceType.GetStringValue(), dayAndStartTime.ToFitbitFormat()); } apiCall = FitbitClientHelperExtensions.ToFullUrl(apiCall); HttpResponseMessage response = await HttpClient.GetAsync(apiCall); await HandleResponse(response); string responseBody = await response.Content.ReadAsStringAsync(); if (string.IsNullOrWhiteSpace(responseBody)) { throw new FitbitRequestException(response, null, "The Intraday data response body was null"); } var serializer = new JsonDotNetSerializer { RootProperty = timeSeriesResourceType.ToTimeSeriesProperty() }; IntradayData data = null; try { data = serializer.GetIntradayTimeSeriesData(responseBody); } catch (Exception ex) { FitbitRequestException fEx = new FitbitRequestException(response, null, "Serialization Error in GetIntradayTimeSeriesData", ex); throw fEx; } return(data); }
/// <summary> /// Requests the friends of the encoded user id or if none supplied the current logged in user /// </summary> /// <param name="encodedUserId">encoded user id, can be null for current logged in user</param> /// <returns>List of <see cref="UserProfile"/></returns> public async Task <List <UserProfile> > GetFriendsAsync(string encodedUserId = default(string)) { string apiCall = FitbitClientHelperExtensions.ToFullUrl("/1/user/{0}/friends.json", encodedUserId); HttpResponseMessage response = await HttpClient.GetAsync(apiCall); await HandleResponse(response); string responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer(); return(serializer.GetFriends(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> /// 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> /// 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> /// Get TimeSeries data for another user accessible with this user's credentials /// </summary> /// <param name="timeSeriesResourceType"></param> /// <param name="baseDate"></param> /// <param name="endDateOrPeriod"></param> /// <param name="encodedUserId"></param> /// <returns></returns> private async Task <TimeSeriesDataListInt> GetTimeSeriesIntAsync(TimeSeriesResourceType timeSeriesResourceType, DateTime baseDate, string endDateOrPeriod, string encodedUserId) { var apiCall = FitbitClientHelperExtensions.ToFullUrl("/1/user/{0}{1}/date/{2}/{3}.json", encodedUserId, timeSeriesResourceType.GetStringValue(), baseDate.ToFitbitFormat(), endDateOrPeriod); HttpResponseMessage response = await HttpClient.GetAsync(apiCall); await HandleResponse(response); string responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer { RootProperty = timeSeriesResourceType.ToTimeSeriesProperty() }; return(serializer.GetTimeSeriesDataListInt(responseBody)); }
/// <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> /// 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 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> /// Request to get heart rate in specific in a range time /// </summary> /// <param name="date"></param> /// <param name="dateRangePeriod"></param> /// <param name="userId"></param> /// <returns></returns> public async Task <HeartActivitiesTimeSeries> GetHeartRateTimeSeries(DateTime date, DateRangePeriod dateRangePeriod, string userId = null) { if (string.IsNullOrWhiteSpace(userId)) { userId = "-"; } string apiCall = String.Format("https://api.fitbit.com/1.1/user/{0}/activities/heart/date/{1}/{2}.json", userId, date.ToString("yyyy-MM-dd"), dateRangePeriod.GetStringValue()); HttpResponseMessage response = await HttpClient.GetAsync(apiCall); await HandleResponse(response); string responseBody = await response.Content.ReadAsStringAsync(); var seralizer = new JsonDotNetSerializer(); var fitbitResponse = seralizer.GetHeartActivitiesTimeSeries(responseBody); return(fitbitResponse); }
/// <summary> /// Add subscription /// </summary> /// <param name="apiCollectionType"></param> /// <param name="uniqueSubscriptionId"></param> /// <param name="subscriberId"></param> /// <returns></returns> public async Task <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)); await HandleResponse(response); var responseBody = await response.Content.ReadAsStringAsync(); var serializer = new JsonDotNetSerializer(); return(serializer.Deserialize <ApiSubscription>(responseBody)); }