Added support for proxy configs in auth flows, closes #360

JohnnyCrazy · JohnnyCrazy · commit 4933deaf26e2 · 2019-07-17T17:39:51.000+02:00
diff --git a/SpotifyAPI.Web.Auth/AuthorizationCodeAuth.cs b/SpotifyAPI.Web.Auth/AuthorizationCodeAuth.cs
@@ -15,6 +15,8 @@ namespace SpotifyAPI.Web.Auth
     public class AuthorizationCodeAuth : SpotifyAuthServer<AuthorizationCode>
     {
         public string SecretId { get; set; }
+        
+        public ProxyConfig ProxyConfig { get; set; }
 
         public AuthorizationCodeAuth(string redirectUri, string serverUri, Scope scope = Scope.None, string state = "")
             : base("code", "AuthorizationCodeAuth", redirectUri, serverUri, scope, state)
@@ -53,7 +55,8 @@ public async Task<Token> RefreshToken(string refreshToken)
                 new KeyValuePair<string, string>("refresh_token", refreshToken)
             };
 
-            HttpClient client = new HttpClient();
+            HttpClientHandler handler = ProxyConfig.CreateClientHandler(ProxyConfig);
+            HttpClient client = new HttpClient(handler);
             client.DefaultRequestHeaders.Add("Authorization", GetAuthHeader());
             HttpContent content = new FormUrlEncodedContent(args);
 
diff --git a/SpotifyAPI.Web.Auth/CredentialsAuth.cs b/SpotifyAPI.Web.Auth/CredentialsAuth.cs
@@ -13,6 +13,8 @@ public class CredentialsAuth
         public string ClientSecret { get; set; }
 
         public string ClientId { get; set; }
+        
+        public ProxyConfig ProxyConfig { get; set; }
 
         public CredentialsAuth(string clientId, string clientSecret)
         {
@@ -29,7 +31,8 @@ public async Task<Token> GetToken()
                 new KeyValuePair<string, string>("grant_type", "client_credentials")
             };
 
-            HttpClient client = new HttpClient();
+            HttpClientHandler handler = ProxyConfig.CreateClientHandler(ProxyConfig);
+            HttpClient client = new HttpClient(handler);
             client.DefaultRequestHeaders.Add("Authorization", $"Basic {auth}");
             HttpContent content = new FormUrlEncodedContent(args);
 
diff --git a/SpotifyAPI.Web.Auth/TokenSwapAuth.cs b/SpotifyAPI.Web.Auth/TokenSwapAuth.cs
@@ -22,30 +22,34 @@ namespace SpotifyAPI.Web.Auth
     /// </summary>
     public class TokenSwapAuth : SpotifyAuthServer<AuthorizationCode>
     {
-        string exchangeServerUri;
+        readonly string _exchangeServerUri;
 
         /// <summary>
         /// The HTML to respond with when the callback server (serverUri) is reached. The default value will close the window on arrival.
         /// </summary>
         public string HtmlResponse { get; set; } = "<script>window.close();</script>";
+
         /// <summary>
         /// If true, will time how long it takes for access to expire. On expiry, the <see cref="OnAccessTokenExpired"/> event fires.
         /// </summary>
         public bool TimeAccessExpiry { get; set; }
 
+        public ProxyConfig ProxyConfig { get; set; }
+
         /// <param name="exchangeServerUri">The URI to an exchange server that will perform the key exchange.</param>
         /// <param name="serverUri">The URI to host the server at that your exchange server should return the authorization code to by GET request. (e.g. http://localhost:4002)</param>
         /// <param name="scope"></param>
         /// <param name="state">Stating none will randomly generate a state parameter.</param>
         /// <param name="htmlResponse">The HTML to respond with when the callback server (serverUri) is reached. The default value will close the window on arrival.</param>
-        public TokenSwapAuth(string exchangeServerUri, string serverUri, Scope scope = Scope.None, string state = "", string htmlResponse = "") : base("code", "", "", serverUri, scope, state)
+        public TokenSwapAuth(string exchangeServerUri, string serverUri, Scope scope = Scope.None, string state = "",
+            string htmlResponse = "") : base("code", "", "", serverUri, scope, state)
         {
             if (!string.IsNullOrEmpty(htmlResponse))
             {
                 HtmlResponse = htmlResponse;
             }
 
-            this.exchangeServerUri = exchangeServerUri;
+            _exchangeServerUri = exchangeServerUri;
         }
 
         protected override void AdaptWebServer(WebServer webServer)
@@ -55,7 +59,7 @@ protected override void AdaptWebServer(WebServer webServer)
 
         public override string GetUri()
         {
-            StringBuilder builder = new StringBuilder(exchangeServerUri);
+            StringBuilder builder = new StringBuilder(_exchangeServerUri);
             builder.Append("?");
             builder.Append("response_type=code");
             builder.Append("&state=" + State);
@@ -64,8 +68,6 @@ public override string GetUri()
             return Uri.EscapeUriString(builder.ToString());
         }
 
-        static readonly HttpClient httpClient = new HttpClient();
-
         /// <summary>
         /// The maximum amount of times to retry getting a token.
         /// <para/>
@@ -85,26 +87,32 @@ public override string GetUri()
         /// <param name="refreshToken">This needs to be defined if "grantType" is "refresh_token".</param>
         /// <param name="currentRetries">Does not need to be defined. Used internally for retry attempt recursion.</param>
         /// <returns>Attempts to return a full <see cref="Token"/>, but after retry attempts, may return a <see cref="Token"/> with no <see cref="Token.AccessToken"/>, or null.</returns>
-        async Task<Token> GetToken(string grantType, string authorizationCode = "", string refreshToken = "", int currentRetries = 0)
+        async Task<Token> GetToken(string grantType, string authorizationCode = "", string refreshToken = "",
+            int currentRetries = 0)
         {
-            var content = new FormUrlEncodedContent(new Dictionary<string, string>
-                {
-                    { "grant_type", grantType },
-                    { "code", authorizationCode },
-                    { "refresh_token", refreshToken }
-                });
+            FormUrlEncodedContent content = new FormUrlEncodedContent(new Dictionary<string, string>
+            {
+                {"grant_type", grantType},
+                {"code", authorizationCode},
+                {"refresh_token", refreshToken}
+            });
 
             try
             {
-                var siteResponse = await httpClient.PostAsync(exchangeServerUri, content);
+                HttpClientHandler handler = ProxyConfig.CreateClientHandler(ProxyConfig);
+                HttpClient client = new HttpClient(handler);
+                HttpResponseMessage siteResponse = await client.PostAsync(_exchangeServerUri, content);
+
                 Token token = JsonConvert.DeserializeObject<Token>(await siteResponse.Content.ReadAsStringAsync());
                 // Don't need to check if it was null - if it is, it will resort to the catch block.
                 if (!token.HasError() && !string.IsNullOrEmpty(token.AccessToken))
                 {
                     return token;
                 }
             }
-            catch { }
+            catch
+            {
+            }
 
             if (currentRetries >= MaxGetTokenRetries)
             {
@@ -120,7 +128,8 @@ async Task<Token> GetToken(string grantType, string authorizationCode = "", stri
             }
         }
 
-        System.Timers.Timer accessTokenExpireTimer;
+        System.Timers.Timer _accessTokenExpireTimer;
+
         /// <summary>
         /// When Spotify authorization has expired. Will only trigger if <see cref="TimeAccessExpiry"/> is true.
         /// </summary>
@@ -134,19 +143,19 @@ void SetAccessExpireTimer(Token token)
         {
             if (!TimeAccessExpiry) return;
 
-            if (accessTokenExpireTimer != null)
+            if (_accessTokenExpireTimer != null)
             {
-                accessTokenExpireTimer.Stop();
-                accessTokenExpireTimer.Dispose();
+                _accessTokenExpireTimer.Stop();
+                _accessTokenExpireTimer.Dispose();
             }
 
-            accessTokenExpireTimer = new System.Timers.Timer
+            _accessTokenExpireTimer = new System.Timers.Timer
             {
                 Enabled = true,
                 Interval = token.ExpiresIn * 1000,
                 AutoReset = false
             };
-            accessTokenExpireTimer.Elapsed += (sender, e) => OnAccessTokenExpired?.Invoke(this, EventArgs.Empty);
+            _accessTokenExpireTimer.Elapsed += (sender, e) => OnAccessTokenExpired?.Invoke(this, EventArgs.Empty);
         }
 
         /// <summary>
@@ -161,6 +170,7 @@ public async Task<Token> ExchangeCodeAsync(string authorizationCode)
             {
                 SetAccessExpireTimer(token);
             }
+
             return token;
         }
 
@@ -176,6 +186,7 @@ public async Task<Token> RefreshAuthAsync(string refreshToken)
             {
                 SetAccessExpireTimer(token);
             }
+
             return token;
         }
     }
@@ -204,7 +215,7 @@ public Task<bool> GetAuth()
                 Code = code,
                 Error = error
             }));
-            return HttpContext.HtmlResponseAsync(((TokenSwapAuth)auth).HtmlResponse);
+            return HttpContext.HtmlResponseAsync(((TokenSwapAuth) auth).HtmlResponse);
         }
     }
-}
+}
diff --git a/SpotifyAPI.Web/ProxyConfig.cs b/SpotifyAPI.Web/ProxyConfig.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Net;
+using System.Net.Http;
 
 namespace SpotifyAPI.Web
 {
@@ -73,5 +74,24 @@ public WebProxy CreateWebProxy()
 
             return proxy;
         }
+        
+        public static HttpClientHandler CreateClientHandler(ProxyConfig proxyConfig = null)
+        {
+            HttpClientHandler clientHandler = new HttpClientHandler
+            {
+                PreAuthenticate = false,
+                UseDefaultCredentials = true,
+                UseProxy = false
+            };
+
+            if (string.IsNullOrWhiteSpace(proxyConfig?.Host)) return clientHandler;
+            WebProxy proxy = proxyConfig.CreateWebProxy();
+            clientHandler.UseProxy = true;
+            clientHandler.Proxy = proxy;
+            clientHandler.UseDefaultCredentials = proxy.UseDefaultCredentials;
+            clientHandler.PreAuthenticate = proxy.UseDefaultCredentials;
+
+            return clientHandler;
+        }
     }
 }
diff --git a/SpotifyAPI.Web/SpotifyWebClient.cs b/SpotifyAPI.Web/SpotifyWebClient.cs
@@ -20,7 +20,7 @@ internal class SpotifyWebClient : IClient
 
         public SpotifyWebClient(ProxyConfig proxyConfig = null)
         {
-            HttpClientHandler clientHandler = CreateClientHandler(proxyConfig);
+            HttpClientHandler clientHandler = ProxyConfig.CreateClientHandler(proxyConfig);
             _client = new HttpClient(clientHandler);
         }
 
@@ -200,24 +200,5 @@ private void AddHeaders(Dictionary<string,string> headers)
                 _client.DefaultRequestHeaders.TryAddWithoutValidation(headerPair.Key, headerPair.Value);
             }
         }
-
-        private static HttpClientHandler CreateClientHandler(ProxyConfig proxyConfig = null)
-        {
-            HttpClientHandler clientHandler = new HttpClientHandler
-            {
-                PreAuthenticate = false,
-                UseDefaultCredentials = true,
-                UseProxy = false
-            };
-
-            if (string.IsNullOrWhiteSpace(proxyConfig?.Host)) return clientHandler;
-            WebProxy proxy = proxyConfig.CreateWebProxy();
-            clientHandler.UseProxy = true;
-            clientHandler.Proxy = proxy;
-            clientHandler.UseDefaultCredentials = proxy.UseDefaultCredentials;
-            clientHandler.PreAuthenticate = proxy.UseDefaultCredentials;
-
-            return clientHandler;
-        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -22,30 +22,34 @@ namespace SpotifyAPI.Web.Auth`
`22`	`22`	`/// </summary>`
`23`	`23`	`public class TokenSwapAuth : SpotifyAuthServer<AuthorizationCode>`
`24`	`24`	`{`
`25`		`- string exchangeServerUri;`
	`25`	`+ readonly string _exchangeServerUri;`
`26`	`26`
`27`	`27`	`/// <summary>`
`28`	`28`	`/// The HTML to respond with when the callback server (serverUri) is reached. The default value will close the window on arrival.`
`29`	`29`	`/// </summary>`
`30`	`30`	`public string HtmlResponse { get; set; } = "<script>window.close();</script>";`
	`31`	`+`
`31`	`32`	`/// <summary>`
`32`	`33`	`/// If true, will time how long it takes for access to expire. On expiry, the <see cref="OnAccessTokenExpired"/> event fires.`
`33`	`34`	`/// </summary>`
`34`	`35`	`public bool TimeAccessExpiry { get; set; }`
`35`	`36`
	`37`	`+ public ProxyConfig ProxyConfig { get; set; }`
	`38`	`+`
`36`	`39`	`/// <param name="exchangeServerUri">The URI to an exchange server that will perform the key exchange.</param>`
`37`	`40`	`/// <param name="serverUri">The URI to host the server at that your exchange server should return the authorization code to by GET request. (e.g. http://localhost:4002)</param>`
`38`	`41`	`/// <param name="scope"></param>`
`39`	`42`	`/// <param name="state">Stating none will randomly generate a state parameter.</param>`
`40`	`43`	`/// <param name="htmlResponse">The HTML to respond with when the callback server (serverUri) is reached. The default value will close the window on arrival.</param>`
`41`		`- public TokenSwapAuth(string exchangeServerUri, string serverUri, Scope scope = Scope.None, string state = "", string htmlResponse = "") : base("code", "", "", serverUri, scope, state)`
	`44`	`+ public TokenSwapAuth(string exchangeServerUri, string serverUri, Scope scope = Scope.None, string state = "",`
	`45`	`+ string htmlResponse = "") : base("code", "", "", serverUri, scope, state)`
`42`	`46`	`{`
`43`	`47`	`if (!string.IsNullOrEmpty(htmlResponse))`
`44`	`48`	`{`
`45`	`49`	`HtmlResponse = htmlResponse;`
`46`	`50`	`}`
`47`	`51`
`48`		`- this.exchangeServerUri = exchangeServerUri;`
	`52`	`+ _exchangeServerUri = exchangeServerUri;`
`49`	`53`	`}`
`50`	`54`
`51`	`55`	`protected override void AdaptWebServer(WebServer webServer)`
`@@ -55,7 +59,7 @@ protected override void AdaptWebServer(WebServer webServer)`
`55`	`59`
`56`	`60`	`public override string GetUri()`
`57`	`61`	`{`
`58`		`- StringBuilder builder = new StringBuilder(exchangeServerUri);`
	`62`	`+ StringBuilder builder = new StringBuilder(_exchangeServerUri);`
`59`	`63`	`builder.Append("?");`
`60`	`64`	`builder.Append("response_type=code");`
`61`	`65`	`builder.Append("&state=" + State);`
`@@ -64,8 +68,6 @@ public override string GetUri()`
`64`	`68`	`return Uri.EscapeUriString(builder.ToString());`
`65`	`69`	`}`
`66`	`70`
`67`		`- static readonly HttpClient httpClient = new HttpClient();`
`68`		`-`
`69`	`71`	`/// <summary>`
`70`	`72`	`/// The maximum amount of times to retry getting a token.`
`71`	`73`	`/// <para/>`
`@@ -85,26 +87,32 @@ public override string GetUri()`
`85`	`87`	`/// <param name="refreshToken">This needs to be defined if "grantType" is "refresh_token".</param>`
`86`	`88`	`/// <param name="currentRetries">Does not need to be defined. Used internally for retry attempt recursion.</param>`
`87`	`89`	`/// <returns>Attempts to return a full <see cref="Token"/>, but after retry attempts, may return a <see cref="Token"/> with no <see cref="Token.AccessToken"/>, or null.</returns>`
`88`		`- async Task<Token> GetToken(string grantType, string authorizationCode = "", string refreshToken = "", int currentRetries = 0)`
	`90`	`+ async Task<Token> GetToken(string grantType, string authorizationCode = "", string refreshToken = "",`
	`91`	`+ int currentRetries = 0)`
`89`	`92`	`{`
`90`		`- var content = new FormUrlEncodedContent(new Dictionary<string, string>`
`91`		`- {`
`92`		`- { "grant_type", grantType },`
`93`		`- { "code", authorizationCode },`
`94`		`- { "refresh_token", refreshToken }`
`95`		`- });`
	`93`	`+ FormUrlEncodedContent content = new FormUrlEncodedContent(new Dictionary<string, string>`
	`94`	`+ {`
	`95`	`+ {"grant_type", grantType},`
	`96`	`+ {"code", authorizationCode},`
	`97`	`+ {"refresh_token", refreshToken}`
	`98`	`+ });`
`96`	`99`
`97`	`100`	`try`
`98`	`101`	`{`
`99`		`- var siteResponse = await httpClient.PostAsync(exchangeServerUri, content);`
	`102`	`+ HttpClientHandler handler = ProxyConfig.CreateClientHandler(ProxyConfig);`
	`103`	`+ HttpClient client = new HttpClient(handler);`
	`104`	`+ HttpResponseMessage siteResponse = await client.PostAsync(_exchangeServerUri, content);`
	`105`	`+`
`100`	`106`	`Token token = JsonConvert.DeserializeObject<Token>(await siteResponse.Content.ReadAsStringAsync());`
`101`	`107`	`// Don't need to check if it was null - if it is, it will resort to the catch block.`
`102`	`108`	`if (!token.HasError() && !string.IsNullOrEmpty(token.AccessToken))`
`103`	`109`	`{`
`104`	`110`	`return token;`
`105`	`111`	`}`
`106`	`112`	`}`
`107`		`- catch { }`
	`113`	`+ catch`
	`114`	`+ {`
	`115`	`+ }`
`108`	`116`
`109`	`117`	`if (currentRetries >= MaxGetTokenRetries)`
`110`	`118`	`{`
`@@ -120,7 +128,8 @@ async Task<Token> GetToken(string grantType, string authorizationCode = "", stri`
`120`	`128`	`}`
`121`	`129`	`}`
`122`	`130`
`123`		`- System.Timers.Timer accessTokenExpireTimer;`
	`131`	`+ System.Timers.Timer _accessTokenExpireTimer;`
	`132`	`+`
`124`	`133`	`/// <summary>`
`125`	`134`	`/// When Spotify authorization has expired. Will only trigger if <see cref="TimeAccessExpiry"/> is true.`
`126`	`135`	`/// </summary>`
`@@ -134,19 +143,19 @@ void SetAccessExpireTimer(Token token)`
`134`	`143`	`{`
`135`	`144`	`if (!TimeAccessExpiry) return;`
`136`	`145`
`137`		`- if (accessTokenExpireTimer != null)`
	`146`	`+ if (_accessTokenExpireTimer != null)`
`138`	`147`	`{`
`139`		`- accessTokenExpireTimer.Stop();`
`140`		`- accessTokenExpireTimer.Dispose();`
	`148`	`+ _accessTokenExpireTimer.Stop();`
	`149`	`+ _accessTokenExpireTimer.Dispose();`
`141`	`150`	`}`
`142`	`151`
`143`		`- accessTokenExpireTimer = new System.Timers.Timer`
	`152`	`+ _accessTokenExpireTimer = new System.Timers.Timer`
`144`	`153`	`{`
`145`	`154`	`Enabled = true,`
`146`	`155`	`Interval = token.ExpiresIn * 1000,`
`147`	`156`	`AutoReset = false`
`148`	`157`	`};`
`149`		`- accessTokenExpireTimer.Elapsed += (sender, e) => OnAccessTokenExpired?.Invoke(this, EventArgs.Empty);`
	`158`	`+ _accessTokenExpireTimer.Elapsed += (sender, e) => OnAccessTokenExpired?.Invoke(this, EventArgs.Empty);`
`150`	`159`	`}`
`151`	`160`
`152`	`161`	`/// <summary>`
`@@ -161,6 +170,7 @@ public async Task<Token> ExchangeCodeAsync(string authorizationCode)`
`161`	`170`	`{`
`162`	`171`	`SetAccessExpireTimer(token);`
`163`	`172`	`}`
	`173`	`+`
`164`	`174`	`return token;`
`165`	`175`	`}`
`166`	`176`
`@@ -176,6 +186,7 @@ public async Task<Token> RefreshAuthAsync(string refreshToken)`
`176`	`186`	`{`
`177`	`187`	`SetAccessExpireTimer(token);`
`178`	`188`	`}`
	`189`	`+`
`179`	`190`	`return token;`
`180`	`191`	`}`
`181`	`192`	`}`
`@@ -204,7 +215,7 @@ public Task<bool> GetAuth()`
`204`	`215`	`Code = code,`
`205`	`216`	`Error = error`
`206`	`217`	`}));`
`207`		`- return HttpContext.HtmlResponseAsync(((TokenSwapAuth)auth).HtmlResponse);`
	`218`	`+ return HttpContext.HtmlResponseAsync(((TokenSwapAuth) auth).HtmlResponse);`
`208`	`219`	`}`
`209`	`220`	`}`
`210`		`-}`
	`221`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ internal class SpotifyWebClient : IClient`
`20`	`20`
`21`	`21`	`public SpotifyWebClient(ProxyConfig proxyConfig = null)`
`22`	`22`	`{`
`23`		`- HttpClientHandler clientHandler = CreateClientHandler(proxyConfig);`
	`23`	`+ HttpClientHandler clientHandler = ProxyConfig.CreateClientHandler(proxyConfig);`
`24`	`24`	`_client = new HttpClient(clientHandler);`
`25`	`25`	`}`
`26`	`26`
`@@ -200,24 +200,5 @@ private void AddHeaders(Dictionary<string,string> headers)`
`200`	`200`	`_client.DefaultRequestHeaders.TryAddWithoutValidation(headerPair.Key, headerPair.Value);`
`201`	`201`	`}`
`202`	`202`	`}`
`203`		`-`
`204`		`- private static HttpClientHandler CreateClientHandler(ProxyConfig proxyConfig = null)`
`205`		`- {`
`206`		`- HttpClientHandler clientHandler = new HttpClientHandler`
`207`		`- {`
`208`		`- PreAuthenticate = false,`
`209`		`- UseDefaultCredentials = true,`
`210`		`- UseProxy = false`
`211`		`- };`
`212`		`-`
`213`		`- if (string.IsNullOrWhiteSpace(proxyConfig?.Host)) return clientHandler;`
`214`		`- WebProxy proxy = proxyConfig.CreateWebProxy();`
`215`		`- clientHandler.UseProxy = true;`
`216`		`- clientHandler.Proxy = proxy;`
`217`		`- clientHandler.UseDefaultCredentials = proxy.UseDefaultCredentials;`
`218`		`- clientHandler.PreAuthenticate = proxy.UseDefaultCredentials;`
`219`		`-`
`220`		`- return clientHandler;`
`221`		`- }`
`222`	`203`	`}`
`223`	`204`	`}`