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"); } }