private async Task RefreshAccessTokenIfNeededAsync(StravaToken token)
{
// check if strava token should be refreshed
if ((token.ExpirationDate.AddSeconds(-60)).ToUniversalTime() > DateTimeOffset.UtcNow)
{
return;
}
var httpClient = this.httpClientFactory.CreateClient();
var refreshResponse = await httpClient.RequestRefreshTokenAsync(
new RefreshTokenRequest
{
Address = StravaAuthenticationDefaults.TokenEndpoint,
ClientId = configuration["StravaClientId"],
ClientSecret = configuration["StravaClientSecret"],
RefreshToken = token.RefreshToken
});
token.AccessToken = refreshResponse.AccessToken;
token.RefreshToken = refreshResponse.RefreshToken;
token.TokenType = refreshResponse.TokenType;
token.ExpirationDate = DateTimeOffset.UtcNow.AddSeconds(refreshResponse.ExpiresIn);
token.TokenRefresh();
}
private async Task RefreshToken()
{
var request = new RestRequest("/oauth/token");
request.Method = Method.POST;
request.AddHeader("Accept", "application/json");
request.AddParameter("client_id", _settings.ClientId);
request.AddParameter("client_secret", _settings.ClientSecret);
if (_token != null && !string.IsNullOrWhiteSpace(_token.RefreshToken) && DateTime.Now > _token.Expiry)
{
request.AddParameter("refresh_token", _token.RefreshToken);
request.AddParameter("grant_type", "refresh_token");
}
else if (_token == null || string.IsNullOrWhiteSpace(_token.AccessToken))
{
request.AddParameter("code", _settings.Code);
request.AddParameter("grant_type", "authorization_code");
}
TokenDto tokenDto = await Execute <TokenDto>(request, false);
_token = new StravaToken
{
AccessToken = tokenDto?.access_token ?? throw new Exception("Cannot obtain access token from the strava api"),
RefreshToken = tokenDto?.refresh_token ?? throw new Exception("Cannot obtain refresh token from the strava api"),
Expiry = DateTime.Now.AddSeconds(tokenDto.expires_in)
};
await _tokenService.Add(_token);
}
public async Task <StravaToken> GetToken()
{
StravaToken token = await _dbContext
.Tokens
.OrderByDescending(e => e.Expiry)
.FirstOrDefaultAsync();
return(token);
}
private async Task ValidateToken()
{
if (_token == null)
{
_token = await _tokenService.GetToken();
}
if (_token == null || string.IsNullOrWhiteSpace(_token.AccessToken) || DateTime.Now > _token.Expiry)
{
await RefreshToken();
}
}
private async Task <List <Activity> > GetActivitiesFromStrava(StravaToken stravaToken, DateTimeOffset startTime)
{
try
{
var stravaActivites = await this.stravaWrapper.GetAthleteActivites(stravaToken, startTime, endTime : null);
return(this.mapper.Map <List <Activity> >(stravaActivites));
}
catch (Exception)
{
return(null);
}
}
private async Task <List <Club> > GetClubsFromStrava(StravaToken stravaToken)
{
try
{
var stravaClubs = await this.stravaWrapper.GetAthleteClubs(stravaToken);
return(this.mapper.Map <List <Club> >(stravaClubs));
}
catch (Exception)
{
return(null);
}
}
private void UpdateStravaToken(long athleteId, StravaToken token)
{
var athlete = this.db.Athletes.Include(p => p.AthleteStravaToken).FirstOrDefault(p => p.Id == athleteId);
if (athlete.AthleteStravaToken == null)
{
athlete.AthleteStravaToken = new AthleteStravaToken();
}
athlete.AthleteStravaToken.LastUpdateDate = DateTimeOffset.UtcNow;
athlete.AthleteStravaToken.AccessToken = token.AccessToken;
athlete.AthleteStravaToken.RefreshToken = token.RefreshToken;
athlete.AthleteStravaToken.TokenType = token.TokenType;
athlete.AthleteStravaToken.ExpirationDate = token.ExpirationDate;
this.db.SaveChanges();
}
public void UpdateStravaToken(long athleteId, AuthenticationProperties properties)
{
var authenticationTokens = properties.GetTokens();
var stravaToken = new StravaToken
{
AccessToken = authenticationTokens.FirstOrDefault(p => p.Name == "access_token")?.Value,
RefreshToken = authenticationTokens.FirstOrDefault(p => p.Name == "refresh_token")?.Value,
TokenType = authenticationTokens.FirstOrDefault(p => p.Name == "token_type")?.Value
};
var expiresAt = authenticationTokens.FirstOrDefault(p => p.Name == "expires_at")?.Value;
stravaToken.ExpirationDate = DateTimeOffset.TryParse(expiresAt, CultureInfo.InvariantCulture, DateTimeStyles.None, out var expiration)
? expiration
: DateTimeOffset.UtcNow;
this.UpdateStravaToken(athleteId, stravaToken);
}
public async Task <DetailedActivity> GetActivity(StravaToken token, long activityId)
{
try
{
await this.RefreshAccessTokenIfNeededAsync(token);
var apiClient = new ApiClient {
AccessToken = token.AccessToken
};
var apiInstance = new ActivitiesApi(apiClient);
return(apiInstance.GetActivityById(activityId, includeAllEfforts: false));
}
catch (Exception)
{
// TODO: log error
return(null);
}
}
public async Task <List <SummaryActivity> > GetAthleteActivites(StravaToken token, DateTimeOffset startTime, DateTimeOffset?endTime = null)
{
var allActivites = new List <SummaryActivity>();
var minActivityDateTime = startTime > ActivitiesMinDataTime ? startTime : ActivitiesMinDataTime;
var maxActivityDateTime = endTime ?? DateTimeOffset.UtcNow;
var minActivityEpochTime = (int)minActivityDateTime.ToUnixTimeSeconds();
var maxActivityEpochTime = (int)maxActivityDateTime.ToUnixTimeSeconds();
var pageNumber = 1;
try
{
await this.RefreshAccessTokenIfNeededAsync(token);
var apiClient = new ApiClient {
AccessToken = token.AccessToken
};
var apiInstance = new ActivitiesApi(apiClient);
while (true)
{
var activites = apiInstance.GetLoggedInAthleteActivities(maxActivityEpochTime, minActivityEpochTime, pageNumber, StravaConsts.MaxApiRecordsPerPage);
allActivites.AddRange(activites);
if (activites.Count <= StravaConsts.MaxApiRecordsPerPage * 0.9)
{
break;
}
else
{
pageNumber++;
}
}
}
catch (Exception)
{
// TODO: log error
throw;
}
return(allActivites);
}
public async Task <List <SummaryClub> > GetAthleteClubs(StravaToken token)
{
var allClubs = new List <SummaryClub>();
var pageNumber = 1;
try
{
await this.RefreshAccessTokenIfNeededAsync(token);
var apiClient = new ApiClient {
AccessToken = token.AccessToken
};
var apiInstance = new ClubsApi(apiClient);
while (true)
{
var clubs = apiInstance.GetLoggedInAthleteClubs(pageNumber, StravaConsts.MaxApiRecordsPerPage);
allClubs.AddRange(clubs);
if (clubs.Count <= StravaConsts.MaxApiRecordsPerPage * 0.9)
{
break;
}
else
{
pageNumber++;
}
}
}
catch (Exception)
{
// TODO: log error
throw;
}
return(allClubs);
}
public async Task Add(StravaToken token)
{
_dbContext.Tokens.Add(token);
await _dbContext.SaveChangesAsync();
}
