public StravaConnector()
{
const String token = "5a034173fa52b384a43aac8ae83b4293230ef9bc";
StaticAuthentication auth = new StaticAuthentication(token);
client = new StravaClient(auth);
}
public void Initialise(bool existing_data, JOB_Common_Parameters common_data)
{
Common_data = new JOB_Common_Parameters();
Common_data = common_data;
S_auth = new StaticAuthentication(common_data.strava_token);
client = new StravaClient(S_auth);
Activity_details = new Activities_data();
Activity_statistics = new JOB_Activities_Stats();
Utilities = new JOB_Utilities();
if (!existing_data)
{
Logger.Info("No existing user data present - Creating Athlete Data", "Strava V2.0/JOB_Strava_Client/Initialise");
Athlete_data = new JOB_Athlete_data(client, common_data.app_path);
Logger.Info("No existing user data present - Athlete Data created", "Strava V2.0/JOB_Strava_Client/Initialise");
Logger.Info("No existing user data present - Creating Gear Data", "Strava V2.0/JOB_Strava_Client/Initialise");
Gear = new JOB_Gear(client, common_data);
Logger.Info("No existing user data present - Gear Data created", "Strava V2.0/JOB_Strava_Client/Initialise");
}
if (existing_data)
{
Logger.Info("Existing user data present", "Strava V2.0/JOB_Strava_Client/Initialise");
Athlete_data = new JOB_Athlete_data(common_data);
Gear = new JOB_Gear(client, common_data);
Activity_statistics.Read_Activities_stats(common_data.activities_stats_filename_fullpath);
stats_data = new DataTable();
stats_data = Activity_statistics.Calculate_annual_stats();
annual_stats_by_week = new DataTable();
annual_stats_by_week = Activity_statistics.Calculate_annual_stats_by_week();
Logger.Info("Existing user data present - Athlete Data Read and processed", "Strava V2.0/JOB_Strava_Client/Initialise");
}
}
private async void button_Click(object sender, RoutedEventArgs e)
{
var authenticationClient = new AuthenticationClient();
// Check authorization code and access token
if (string.IsNullOrEmpty(App.Settings.AuthorizationCode))
{
App.Settings.AuthorizationCode = await authenticationClient.RequestAccessAsync(App.Settings.ClientId);
App.Settings.AccessToken = await authenticationClient.TokenExchangeAsync(App.Settings.ClientId, App.Settings.ClientSecret, App.Settings.AuthorizationCode);
}
else if (string.IsNullOrEmpty(App.Settings.AccessToken))
{
App.Settings.AccessToken = await authenticationClient.TokenExchangeAsync(App.Settings.ClientId, App.Settings.ClientSecret, App.Settings.AuthorizationCode);
}
var stravaClient = new StravaClient(App.Settings.AccessToken);
var athlete = await stravaClient.Athletes.GetCurrentAthleteAsync();
var activities = await stravaClient.Activities.GetActivities(per_page : 5);
var stream = await stravaClient.Streams.GetActityStreamAsync(activities[0].Id, "latlng");
this.DataContext = new
{
athlete = athlete,
activity = activities[0]
};
}
private void TimerTick(object sender, ElapsedEventArgs e)
{
StaticAuthentication authenticator = new StaticAuthentication(_token);
StravaClient stravaClient = new StravaClient(authenticator);
UploadStatus uploadStatus = stravaClient.Uploads.CheckUploadStatus(_uploadId);
string status = uploadStatus.Status;
switch (status)
{
default:
if (status == "Your activity is ready.")
{
if (this.UploadChecked != null)
{
this.UploadChecked(this, new UploadStatusCheckedEventArgs(CurrentUploadStatus.Ready));
}
if (this.ActivityReady != null)
{
this.ActivityReady(this, EventArgs.Empty);
}
Finish();
}
break;
case "Your activity is still being processed.":
if (this.UploadChecked != null)
{
this.UploadChecked(this, new UploadStatusCheckedEventArgs(CurrentUploadStatus.Processing));
}
if (this.ActivityProcessing != null)
{
this.ActivityProcessing(this, EventArgs.Empty);
}
break;
case "The created activity has been deleted.":
if (this.UploadChecked != null)
{
this.UploadChecked(this, new UploadStatusCheckedEventArgs(CurrentUploadStatus.Deleted));
}
Finish();
break;
case "There was an error processing your activity.":
if (this.UploadChecked != null)
{
this.UploadChecked(this, new UploadStatusCheckedEventArgs(CurrentUploadStatus.Error));
}
ErrorMessage = uploadStatus.Error;
if (this.Error != null)
{
this.Error(this, EventArgs.Empty);
}
Finish();
break;
}
}
public void Test_RequestAllUserActivities()
{
StravaClient stravaClient = new StravaClient(activitiesApi, athleteApi);
List <VisualActivity> result = (List <VisualActivity>)stravaClient.getAllUserActivities("access_token", 123);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(60, result.ToArray()[0].Summary.MovingTime);
Assert.AreEqual(ActivityType.Ride, result.ToArray()[1].Summary.Type);
}
public async Task Test_requestAllUserActivitiesAsync()
{
StravaClient stravaClient = new StravaClient(activitiesApi, athleteApi);
var result = (List <SummaryActivity>) await stravaClient.requestAllUserActivitiesAsync("access_token", 123);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(60, result.ToArray()[0].MovingTime);
Assert.AreEqual(ActivityType.Ride, result.ToArray()[1].Type);
}
public async Task Test_requestActivities()
{
StravaClient stravaClient = new StravaClient(activitiesApi, athleteApi);
var result = (List <SummaryActivity>) await stravaClient.requestActivities(totalRides + totalRuns + totalSwims);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(60, result.ToArray()[0].MovingTime);
Assert.AreEqual(ActivityType.Ride, result.ToArray()[1].Type);
}
public static async Task MyMethodAsync(WebAuthentication wa)
{
StravaClient client = new StravaClient(wa);
// Receive the currently authenticated athlete
List <ActivitySummary> activities = await client.Activities.GetActivitiesAsync(20, 20);
foreach (ActivitySummary Activity in activities)
{
Console.WriteLine($"Email:{Activity.Name} {Activity.Type}");
}
}
static void Main(string[] args)
{
var staticAuthentication = new StaticAuthentication("f112cb279e1ab839bae4918febb5b7a96f199e40");
var web = new WebAuthentication {
AccessToken = "f112cb279e1ab839bae4918febb5b7a96f199e40", AuthCode = ""
};
var client = new StravaClient(staticAuthentication);
var segment = client.Segments.GetSegment("10393462");
var segmentLeaderboard = client.Segments.GetFullSegmentLeaderboard("10393462");
var athlete = client.Athletes.GetAthlete();
}
public void Test_GetUserCoordinatesId_WithAfterDate()
{
StravaClient stravaClient = new StravaClient(activitiesApi, athleteApi);
DateTime dateTime = DateTime.Now;
var result = stravaClient.getUserCoordinatesByIdAfter("access_token", dateTime);
Assert.AreEqual(9, result.Count());
Assert.AreEqual(activitiesAfter.First().StartLatlng[0], result.First().Latitude);
Assert.AreEqual(activitiesAfter.First().StartLatlng[1], result.First().Longitude);
}
public async Task requestActivitiesAfterAsync()
{
StravaClient stravaClient = new StravaClient(activitiesApi, athleteApi);
DateTime dateTime = DateTime.Now;
List <SummaryActivity> result = (List <SummaryActivity>) await stravaClient.requestActivitiesAfterAsync("access_token", dateTime);
Assert.AreEqual(9, result.Count);
Assert.AreEqual(100, result.ToArray()[0].MovingTime);
Assert.AreEqual(ActivityType.Run, result.ToArray()[1].Type);
}
public void Test_RequesUserActivitiesAfter_ZeroRequiredPages()
{
StravaClient stravaClient = new StravaClient(activitiesApi, athleteApi);
DateTime dateTime = DateTime.Now;
activitiesApi.GetLoggedInAthleteActivitiesAsync(page: 1, after: Arg.Any <int>(), perPage: Arg.Any <int>()).Returns(Task.FromResult(emptyActivities));
List <VisualActivity> result = (List <VisualActivity>)stravaClient.getUserActivitiesByIdAfter("access_token", dateTime);
Assert.AreEqual(0, result.Count);
}
public void Test_RequesUserActivitiesAfter()
{
StravaClient stravaClient = new StravaClient(activitiesApi, athleteApi);
DateTime dateTime = DateTime.Now;
List <VisualActivity> result = (List <VisualActivity>)stravaClient.getUserActivitiesByIdAfter("access_token", dateTime);
Assert.AreEqual(9, result.Count);
Assert.AreEqual(100, result.Last().Summary.MovingTime);
Assert.AreEqual(ActivityType.Run, result.First().Summary.Type);
}
private async void finish_StravaConnection(string token)
{
if (strava_Token.Length != 0)
{
auth = new StaticAuthentication(token);
client = new StravaClient(auth);
Athlete athlete = await client.Athletes.GetAthleteAsync();
statusText.Text = "Hello " + athlete.FirstName;
}
}
public void Test_GetAllCoordinatesById()
{
StravaClient stravaClient = new StravaClient(activitiesApi, athleteApi);
var result = stravaClient.getAllUserCoordinatesById("access_token", 123);
Assert.AreEqual(2, result.Count());
Assert.AreEqual(ActivityType.Crossfit.ToString(), result.Last().ActivityType);
Assert.AreEqual(ActivityType.Ride.ToString(), result.First().ActivityType);
Assert.AreEqual(activities.Last().StartLatlng[0], result.First().Latitude);
Assert.AreEqual(activities.Last().StartLatlng[1], result.First().Longitude);
}
public async Task Test_requestActivitiesAfter()
{
StravaClient stravaClient = new StravaClient(activitiesApi, athleteApi);
DateTime dateTime = DateTime.Now;
List <SummaryActivity> result = (List <SummaryActivity>) await stravaClient.requestActivitiesAfter(totalRides + totalRuns + totalSwims, dateTime);
Assert.AreEqual(9, result.Count);
Assert.AreEqual(100, result.ToArray()[0].MovingTime);
Assert.AreEqual(ActivityType.Run, result.ToArray()[1].Type);
}
public ActionResult <IEnumerable <ActivitySummary> > GetActivities()
{
WebAuthentication wa = new WebAuthentication();
wa.AccessToken = User.Claims.First(claim => claim.Type == "token").Value;
var activities = new StravaClient(wa).Activities.GetActivitiesAsync(40, 40).Result;
if (activities == null)
{
return(NotFound());
}
return(activities);
}
Authenticator CreateAuthenticator()
{
var redirectUrl = $"{Request.Url.Scheme}://{Request.Url.Host}/Home/Callback";
var config = new RuntimeClientConfiguration
{
IsEnabled = false,
ClientId = Config.ClientId,
ClientSecret = Config.ClientSecret,
RedirectUri = redirectUrl,
Scope = "write,view_private"
};
var client = new StravaClient(new RequestFactory(), config);
return(new Authenticator(client));
}
public void Test_RequesUserActivitiesAfter_ZeroRequiredPages()
{
StravaClient stravaClient = new StravaClient(activitiesApi, athleteApi);
DateTime dateTime = DateTime.Now;
var user = new StravaUser()
{
VisualActivities = null,
UserId = 123,
LastDownload = dateTime
};
//List<VisualActivity> result = (List<VisualActivity>) stravaClient.getUserActivitiesAfter("access_token", 123, dateTime);
List <VisualActivity> result = (List <VisualActivity>)stravaClient.getUserActivitiesAfter("access_token", user, dateTime);
Assert.AreEqual(0, result.Count);
}
public Authenticator CreateAuthenticator(HttpRequestBase request)
{
var redirectUrl = string.Format("{0}://{1}:{2}/Home/Callback", request.Url.Scheme, request.Url.Host, request.Url.Port);
var config = new RestSharp.Portable.OAuth2.Configuration.RuntimeClientConfiguration
{
IsEnabled = false,
ClientId = AppConfigStrava.StravaClientId,
ClientSecret = AppConfigStrava.StravaClientSecret,
RedirectUri = redirectUrl,
Scope = "write,view_private",
};
var client = new StravaClient(new Authentication.RequestFactory(), config);
return(new Authenticator(client));
}
public async Task <IActionResult> Test([FromServices] StravaClient client)
{
var response = await client.GetStarredSegments();
using var document = JsonDocument.Parse(response);
foreach (var element in document.RootElement.EnumerateArray())
{
var segment = JsonSerializer.Deserialize <Segment>(element.GetRawText());
await _segmentRepository.SaveAsync(segment);
}
ViewBag.Json = JArray.Parse(response).ToString();
return(View());
}
private Task <bool> SignIn()
{
var signal = new TaskCompletionSource <bool>();
var auth = new WebAuthentication();
auth.AuthCodeReceived += (s, e) => { this.config.AuthCode = e.AuthCode; };
auth.AccessTokenReceived += (s, e) =>
{
Logger.Log($"Access token received. {e.Token}");
this.config.Token = e.Token;
this.client = new StravaClient(auth);
signal.SetResult(true);
};
auth.GetTokenAsync(this.config.ClientId, this.config.ClientSecret, Scope.Full);
return(signal.Task);
}
public void Test_RequesUserActivitiesAfter()
{
StravaClient stravaClient = new StravaClient(activitiesApi, athleteApi);
DateTime dateTime = DateTime.Now;
var user = new StravaUser()
{
VisualActivities = TestData.VisualActivitiesList(),
UserId = 123,
LastDownload = dateTime
};
//List<VisualActivity> result = (List<VisualActivity>) stravaClient.getUserActivitiesAfter("access_token", 123, dateTime);
List <VisualActivity> result = (List <VisualActivity>)stravaClient.getUserActivitiesAfter("access_token", user, dateTime);
Assert.AreEqual(9, result.Count);
Assert.AreEqual(100, result.ToArray()[0].Summary.MovingTime);
Assert.AreEqual(ActivityType.Run, result.ToArray()[1].Summary.Type);
}
public async Task requestActivitiesAfterAsync()
{
StravaClient stravaClient = new StravaClient(activitiesApi, athleteApi);
DateTime dateTime = DateTime.Now;
var user = new StravaUser()
{
VisualActivities = TestData.VisualActivitiesList(),
UserId = 123,
LastDownload = dateTime
};
List <SummaryActivity> result = (List <SummaryActivity>) await stravaClient.requestActivitiesAfterAsync("access_token", user, dateTime);
Assert.AreEqual(9, result.Count);
Assert.AreEqual(100, result.ToArray()[0].MovingTime);
Assert.AreEqual(ActivityType.Run, result.ToArray()[1].Type);
}
public JOB_Athlete_data(StravaClient client, string application_path)
{
Logger.Info("Getting Athlete Data (new)", "Strava V2.0/JOB_Athlete_data/Constructor");
try
{
athlete = new Athlete();
athlete = client.Athletes.GetAthlete();
Logger.Info("Athlete Data Retrieved", "Strava V2.0/JOB_Athlete_data/Constructor");
Process_FTP();
Populate_athlete();
Common_Data.athlete_id = s_athlete_id;
string athlete_filename_fullpath = Common_Data.athlete_filename_fullpath;
Save_athlete(athlete_filename_fullpath);
}
catch (Exception ex)
{
Logger.Error(ex, "Error #9000 thrown in Strava V2.0/JOB_Athlete_data/Constructor");
}
}
public void Run(string[] args)
{
this.config = AppConfig.CreateOrLoad <Config>();
// Sign in
if (string.IsNullOrEmpty(this.config.Token))
{
// Wait for signin to complete
Logger.Log("Requesting token.");
this.SignIn().Wait();
AppConfig.Save(this.config);
}
else
{
Logger.Log("Using existing token.");
this.client = new StravaClient(new StaticAuthentication(this.config.Token));
}
this.RunLoop();
}
public Profile ImportProfile([FromUri] string activityId, [FromUri] Guid chartId)
{
_log.Debug("Creating profile from strava activity {activityId} med chart {chartId}", activityId, chartId);
StaticAuthentication auth = new StaticAuthentication(GetClaimedToken());
StravaClient client = new StravaClient(auth);
StreamType streamTypes = StreamType.LatLng | StreamType.Distance | StreamType.Altitude | StreamType.Time;
var activity = client.Activities.GetActivity(activityId, true);
var streams = client.Streams.GetActivityStream(activityId, streamTypes);
var id = Guid.NewGuid();
var track = CreateTrack(activity, streams);
var application = ApplicationManager.BuildApplication();
application.ExecuteCommand(new CreateProfile(id, UserId, chartId, activity.Name, track));
return(application.Views.Profiles.GetById(id));
}
Authenticator CreateAuthenticator()
{
string secretkey = String.Empty;
//using (StreamReader reader = new StreamReader(@"C:\Users\qbressler\Desktop\strava_api_key.txt"))
//{
// secretkey = reader.ReadToEnd();
//}
secretkey = ConfigurationManager.AppSettings["clientkey"];
var redirectUrl = $"{Request.Url.Scheme}://{Request.Url.Host}:{Request.Url.Port}/Strava/Callback";
var config = new RestSharp.Portable.OAuth2.Configuration.RuntimeClientConfiguration
{
IsEnabled = true,
ClientId = "18876",
ClientSecret = secretkey,
RedirectUri = redirectUrl,
Scope = "read_all",
};
var client = new StravaClient(new Authentication.RequestFactory(), config);
return(new Authenticator(client));
}
Authenticator CreateAuthenticator()
{
try
{
var redirectUrl = $"{Request.Scheme}://{Request.Host.Host}:{Request.Host.Port}/Home/Callback";
var config = new RestSharp.Portable.OAuth2.Configuration.RuntimeClientConfiguration
{
IsEnabled = false,
ClientId = _configuration["ClientId"],
ClientSecret = _configuration["ClientSecret"],
RedirectUri = redirectUrl,
Scope = "activity:read"
};
var client = new StravaClient(new RequestFactory(), config);
return(new Authenticator(_context, client));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
throw;
}
}
public JOB_Gear(StravaClient client, JOB_Common_Parameters common)
{
Logger.Info("Creating Gear Data", "Strava V2.0/JOB_Gear/Constructor");
JOB_GearSummary = new Bike();
utilities = new JOB_Utilities();
Gear_data = new DataTable();
strava_client = client;
common_data = common;
is_imperial = common.unit_of_measure;
Create_Gear_datatable();
try
{
if (utilities.File_exists(common_data.gear_filename_fullpath))
{
Gear_data = Read_Gear_Data(common_data.gear_filename_fullpath);
Update_gear(Gear_data);
Write_Gear_Data(Gear_data, common_data.gear_filename_fullpath);
}
}
catch (Exception ex)
{
Logger.Error(ex, "Exception occurred in Strava V2.0/JOB_Gear/Constructor");
}
}
