/// <summary>
/// Converts the timeseries resource into the property to acces the data
/// </summary>
/// <param name="timeseriesResource"></param>
/// <returns></returns>
internal static string ToTimeSeriesProperty(this TimeSeriesResourceType timeseriesResource)
{
var timeSeriesResourceDisplay = timeseriesResource.GetStringValue();
if (timeSeriesResourceDisplay.StartsWith("/"))
{
timeSeriesResourceDisplay = timeSeriesResourceDisplay.TrimStart(new[] { '/' });
}
return timeSeriesResourceDisplay.Replace("/", "-");
}
public static decimal ConvertFitbitValue(TimeSeriesResourceType type, string value)
{
// if value is "0" we're going to ignore it so no point converting.
if (value == "0")
{
return(FitbitConversion.InvalidValue);
}
if (type == TimeSeriesResourceType.TimeEnteredBed)
{
return(ConvertFitbitTimeEnteredBed(value));
}
return(Convert.ToDecimal(value));
}
private void DownloadMetric(TimeSeriesResourceType type, DateTime dateStart)
{
TimeSeriesDataList fitbitData = null;
try
{
fitbitData = _client.GetTimeSeriesAsync(type, dateStart, DateRangePeriod.OneYear).Result;
SaveSeries(type, fitbitData);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
return;
}
}
private void DownloadMetric(TimeSeriesResourceType type, bool fullDownload)
{
if (!fullDownload)
{
DownloadMetric(type, DateTime.UtcNow);
}
else
{
// if initial download or a forced refresh then attemt to download last 5 years worth of data.
for (int year = 0; year >= -5; year--)
{
DownloadMetric(type, DateTime.UtcNow.AddYears(year));
}
}
}
/// <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>
/// Get TimeSeries data for another user accessible with this user's credentials
/// </summary>
/// <param name="timeSeriesResourceType"></param>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
/// <param name="userId"></param>
/// <returns></returns>
public TimeSeriesDataListInt GetTimeSeriesInt(TimeSeriesResourceType timeSeriesResourceType, DateTime baseDate, string endDateOrPeriod, string userId)
{
string userSignifier = "-"; //used for current user
if (!string.IsNullOrWhiteSpace(userId))
{
userSignifier = userId;
}
string requestUrl = string.Format("/1/user/{0}{1}/date/{2}/{3}.xml", userSignifier, StringEnum.GetStringValue(timeSeriesResourceType), baseDate.ToString("yyyy-MM-dd"), endDateOrPeriod);
RestRequest request = new RestRequest(requestUrl);
request.OnBeforeDeserialization = resp =>
{
XDocument doc = XDocument.Parse(resp.Content);
//IEnumerable<XElement> links = doc.Descendants("result");
var rootElement = doc.Descendants("result").FirstOrDefault().Descendants().FirstOrDefault();
if (rootElement != null && !string.IsNullOrWhiteSpace(rootElement.Name.LocalName))
{
request.RootElement = rootElement.Name.LocalName;
}
//foreach (XElement link in links)
//{
//RemoveDuplicateElement(link, "category");
//RemoveDuplicateElement(link, "click-commission");
//RemoveDuplicateElement(link, "creative-height");
//RemoveDuplicateElement(link, "creative-width");
//}
};
//request.RootElement = timeSeriesResourceType.GetRootElement();
var response = restClient.Execute <TimeSeriesDataListInt>(request);
HandleResponse(response);
/*
*/
return(response.Data);
}
/// <summary>
/// Return a FitnessViewer.MetricType for a given fitbit resource type.
/// </summary>
/// <param name="type">Fitbit resource type</param>
/// <returns></returns>
public static MetricType FromFitBitType(TimeSeriesResourceType type)
{
switch (type)
{
case TimeSeriesResourceType.Weight: { return(MetricType.Weight); }
case TimeSeriesResourceType.Fat: { return(MetricType.BodyFat); }
case TimeSeriesResourceType.CaloriesIn: { return(MetricType.CaloriesIn); }
case TimeSeriesResourceType.MinutesAsleep: { return(MetricType.SleepMinutes); }
case TimeSeriesResourceType.TimeInBed: { return(MetricType.TimeInBed); }
case TimeSeriesResourceType.TimeEnteredBed: { return(MetricType.TimeEnteredBed); }
default: { return(MetricType.Invalid); }
}
}
private void SaveSeries(TimeSeriesResourceType type, TimeSeriesDataList fitbitData)
{
var metricType = MetricTypeConversion.FromFitBitType(type);
List <Metric> currentlyStoredMetrics = _unitOfWork.CRUDRepository.GetByUserId <Metric>(_userId)
.Where(m => m.MetricType == metricType)
.ToList();
foreach (Fitbit.Models.TimeSeriesDataList.Data item in fitbitData.DataList)
{
// no value so ignore
if (string.IsNullOrEmpty(item.Value))
{
continue;
}
decimal convertedValue = FitbitConversion.ConvertFitbitValue(type, item.Value);
// 0 = no value for the type/date so ignore
if (convertedValue == FitbitConversion.InvalidValue)
{
continue;
}
// check if we already have a metric for the given date.
var existingMetric = currentlyStoredMetrics.Where(m => m.Recorded == item.DateTime).FirstOrDefault();
if (existingMetric == null)
{
// add metric
_unitOfWork.Metrics.AddMetric(Metric.CreateMetric(_userId, metricType, item.DateTime, convertedValue, false));
}
else
{
// don't overwrite any manually entered metrics.
if (!existingMetric.IsManual)
{
existingMetric.Value = convertedValue;
_unitOfWork.Metrics.UpdateMetric(existingMetric);
}
}
}
_unitOfWork.Complete();
}
/// <summary>
/// Converts FitFibt Time Series Data to AF Time Series Data
/// </summary>
/// <param name="tsDataList">FitBit Time Series data</param>
/// <param name="type">Type of fit Bit data - this will determine the attribute name to write into. It can also influence the conversion logic.</param>
/// <param name="element">The element that contains the attribute to write into</param>
/// <param name="attributeName">Name of the AF Attribute in which time series data will be written into.</param>
/// <returns></returns>
public static AFValues ConvertToAFValues(TimeSeriesDataList tsDataList, TimeSeriesResourceType type, AFElement element, string attributeName)
{
// creates the list of values
AFValues values = new AFValues();
foreach (var result in tsDataList.DataList)
{
AFValue val = null;
if (type != TimeSeriesResourceType.TimeEnteredBed)
{
val = new AFValue(Convert.ToSingle(result.Value), new AFTime(result.DateTime));
}
else
{
val = new AFValue(result.Value, new AFTime(result.DateTime));
}
values.Add(val);
}
values.Attribute = element.Attributes[attributeName];
return values;
}
/// <summary>
/// Get TimeSeries data for another user accessible with this user's credentials
/// </summary>
/// <param name="timeSeriesResourceType"></param>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
/// <param name="userId"></param>
/// <returns></returns>
public TimeSeriesDataListInt GetTimeSeriesInt(TimeSeriesResourceType timeSeriesResourceType, DateTime startDate, DateTime endDate, string userId)
{
string userSignifier = "-"; //used for current user
if (!string.IsNullOrWhiteSpace(userId))
userSignifier = userId;
string requestUrl = string.Format("/1/user/{0}{1}/date/{2}/{3}.xml", userSignifier, StringEnum.GetStringValue(timeSeriesResourceType), startDate.ToString("yyyy-MM-dd"), endDate.ToString("yyyy-MM-dd"));
RestRequest request = new RestRequest(requestUrl);
request.OnBeforeDeserialization = resp =>
{
XDocument doc = XDocument.Parse(resp.Content);
//IEnumerable<XElement> links = doc.Descendants("result");
var rootElement = doc.Descendants("result").FirstOrDefault().Descendants().FirstOrDefault();
request.RootElement = rootElement.Name.LocalName;
//foreach (XElement link in links)
//{
//RemoveDuplicateElement(link, "category");
//RemoveDuplicateElement(link, "click-commission");
//RemoveDuplicateElement(link, "creative-height");
//RemoveDuplicateElement(link, "creative-width");
//}
};
//request.RootElement = timeSeriesResourceType.GetRootElement();
var response = restClient.Execute<TimeSeriesDataListInt>(request);
HandleResponseCode(response.StatusCode);
/*
*/
return response.Data;
}
public FitbitStream(TimeSeriesResourceType fitbitSource, string attributeName, UOM uom)
{
FitbitSource = fitbitSource;
AttributeName = attributeName;
UnitsOfMeasure = uom;
}
public TimeSeriesDataList GetTimeSeries(TimeSeriesResourceType timeSeriesResourceType, DateTime endDate, DateRangePeriod period, string userId)
{
return(GetTimeSeries(timeSeriesResourceType, endDate, period.GetStringValue(), userId));
}
/// <summary>
/// Get TimeSeries data for this authenticated user as integer
/// </summary>
/// <param name="timeSeriesResourceType"></param>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
/// <returns></returns>
public TimeSeriesDataListInt GetTimeSeriesInt(TimeSeriesResourceType timeSeriesResourceType, DateTime startDate, DateTime endDate)
{
return GetTimeSeriesInt(timeSeriesResourceType, startDate, endDate, null);
}
public TimeSeriesDataListInt GetTimeSeriesInt(TimeSeriesResourceType timeSeriesResourceType, DateTime endDate, DateRangePeriod period, string userId)
{
return GetTimeSeriesInt(timeSeriesResourceType, endDate, period.GetStringValue(), userId);
}
/// <summary>
/// Requests the specified <see cref="TimeSeriesResourceType"/> for the date range and user specified
/// </summary>
/// <param name="timeSeriesResourceType"></param>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
/// <param name="encodedUserId"></param>
/// <returns></returns>
public async Task <FitbitResponse <TimeSeriesDataList> > GetTimeSeriesAsync(TimeSeriesResourceType timeSeriesResourceType, DateTime startDate, DateTime endDate, string encodedUserId = default(string))
{
return(await GetTimeSeriesAsync(timeSeriesResourceType, startDate, endDate.ToFitbitFormat(), encodedUserId));
}
public TimeSeriesDataListInt GetTimeSeriesInt(TimeSeriesResourceType timeSeriesResourceType, DateTime startDate, DateTime endDate, string userId)
{
return GetTimeSeriesInt(timeSeriesResourceType, startDate, endDate.ToString("yyyy-MM-dd"), userId);
}
public TimeSeriesDataListInt GetTimeSeriesInt(TimeSeriesResourceType timeSeriesResourceType, DateTime endDate, DateRangePeriod period)
{
return GetTimeSeriesInt(timeSeriesResourceType, endDate, period, null);
}
/// <summary>
/// Requests the specified <see cref="TimeSeriesResourceType"/> for the date range and user specified
/// </summary>
/// <param name="timeSeriesResourceType"></param>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
/// <param name="encodedUserId"></param>
/// <returns></returns>
public Task <FitbitResponse <TimeSeriesDataListInt> > GetTimeSeriesIntAsync(TimeSeriesResourceType timeSeriesResourceType, DateTime startDate, DateTime endDate, string encodedUserId = null)
{
return(GetTimeSeriesIntAsync(timeSeriesResourceType, startDate, endDate.ToFitbitFormat(), encodedUserId));
}
/// <summary>
/// Requests the specified <see cref="TimeSeriesResourceType"/> for the date range and user specified
/// </summary>
/// <param name="timeSeriesResourceType"></param>
/// <param name="endDate"></param>
/// <param name="period"></param>
/// <param name="encodedUserId"></param>
/// <returns></returns>
public async Task <FitbitResponse <TimeSeriesDataList> > GetTimeSeriesAsync(TimeSeriesResourceType timeSeriesResourceType, DateTime endDate, DateRangePeriod period, string encodedUserId = default(string))
{
return(await GetTimeSeriesAsync(timeSeriesResourceType, endDate, period.GetStringValue(), encodedUserId));
}
public TimeSeriesDataListInt GetTimeSeriesInt(TimeSeriesResourceType timeSeriesResourceType, DateTime endDate, DateRangePeriod period)
{
return(GetTimeSeriesInt(timeSeriesResourceType, endDate, period, null));
}
/// <summary>
/// Get TimeSeries data for this authenticated user as integer
/// </summary>
/// <param name="timeSeriesResourceType"></param>
/// <param name="startDate"></param>
/// <param name="endDate"></param>
/// <returns></returns>
public TimeSeriesDataListInt GetTimeSeriesInt(TimeSeriesResourceType timeSeriesResourceType, DateTime startDate, DateTime endDate)
{
return(GetTimeSeriesInt(timeSeriesResourceType, startDate, endDate, null));
}
private void CollectAndSaveData(FitbitClient fitBitClient,DateTime startTime,DateTime endTime, AFElement deviceElement, TimeSeriesResourceType type,string attributeName)
{
var fitBitData = fitBitClient.GetTimeSeries(type, startTime, endTime);
AFValues values = Helpers.FitBitHelpers.ConvertToAFValues(fitBitData, type, deviceElement, attributeName);
SharedData.DataQueue.Enqueue(values);
valuesCount += values.Count;
}
public FitbitStream CreateFitbitStream(TimeSeriesResourceType tsResourceType, string attributeName, UOM uom)
{
FitbitStream stream = new FitbitStream(tsResourceType, attributeName, uom);
return stream;
}
/// <summary>
/// Requests the specified <see cref="TimeSeriesResourceType"/> for the date range and user specified
/// </summary>
/// <param name="timeSeriesResourceType"></param>
/// <param name="endDate"></param>
/// <param name="period"></param>
/// <param name="encodedUserId"></param>
/// <returns></returns>
public Task <FitbitResponse <TimeSeriesDataListInt> > GetTimeSeriesIntAsync(TimeSeriesResourceType timeSeriesResourceType, DateTime endDate, DateRangePeriod period, string encodedUserId = null)
{
return(GetTimeSeriesIntAsync(timeSeriesResourceType, endDate, period.GetStringValue(), encodedUserId));
}
public TimeSeriesDataListInt GetTimeSeriesInt(TimeSeriesResourceType timeSeriesResourceType, DateTime startDate, DateTime endDate, string userId)
{
return(GetTimeSeriesInt(timeSeriesResourceType, startDate, endDate.ToString("yyyy-MM-dd"), userId));
}
public TimeSeriesDataListInt GetTimeSeriesInt(TimeSeriesResourceType timeSeriesResourceType, DateTime startDate, DateTime endDate, string userId)
{
string userSignifier = "-";
if (!string.IsNullOrWhiteSpace(userId))
userSignifier = userId;
string requestUrl = string.Format("/1/user/{0}/{1}/date/{2}/{3}.xml", userSignifier, StringEnum.GetStringValue(timeSeriesResourceType), startDate.ToString("yyyy-MM-dd"), endDate.ToString("yyyy-MM-dd"));
RestRequest request = new RestRequest(requestUrl);
request.OnBeforeDeserialization = resp =>
{
XDocument doc = XDocument.Parse(resp.Content);
var rootElement = doc.Descendants("result").FirstOrDefault().Descendants().FirstOrDefault();
request.RootElement = rootElement.Name.LocalName;
};
var response = restClient.Execute<TimeSeriesDataListInt>(request);
HandleResponseCode(response.StatusCode);
return response.Data;
}
public TimeSeriesDataListInt GetTimeSeriesInt(TimeSeriesResourceType timeSeriesResourceType, DateTime endDate, DateRangePeriod period, string userId)
{
return(GetTimeSeriesInt(timeSeriesResourceType, endDate, StringEnum.GetStringValue(period), userId));
}
public TimeSeriesDataList GetTimeSeries(TimeSeriesResourceType timeSeriesResourceType, DateTime endDate, DateRangePeriod period, string userId)
{
return GetTimeSeries(timeSeriesResourceType, endDate, StringEnum.GetStringValue(period), userId);
}
