Exemple #1
0
        public static async Task <IOAuth2Token> GetToken()
        {
            OAuth2Endpoint auth  = new OAuth2Endpoint(new ImgurClient(Properties.Settings.Default.ClientId, Properties.Settings.Default.ClientSecret));
            IOAuth2Token   token = null;

            if (!string.IsNullOrWhiteSpace(Properties.Settings.Default.Token))
            {
                token = JsonConvert.DeserializeObject <OAuth2Token>(Properties.Settings.Default.Token);
                if (token != null)
                {
                    if (token.ExpiresIn > 0)
                    {
                        return(token);
                    }
                    token = await auth.GetTokenByRefreshTokenAsync(token.RefreshToken);

                    Properties.Settings.Default.Token = JsonConvert.SerializeObject(token);
                    Properties.Settings.Default.Save();
                }
            }
            Process.Start(auth.GetAuthorizationUrl(Imgur.API.Enums.OAuth2ResponseType.Pin));
            string pin = await DialogCoordinator.Instance.ShowInputAsync(Context, "Enter Imgur Pin", "");

            token = await auth.GetTokenByPinAsync(pin);

            Properties.Settings.Default.Token = JsonConvert.SerializeObject(token);
            Properties.Settings.Default.Save();
            return(token);
        }
Exemple #2
0
        public async static Task ImgurSetup()
        {
            ApiSettings settings = GetApiLogin();

            Client = new ImgurClient(settings.ClientId, settings.ClientSecret);
            var          endpoint = new OAuth2Endpoint(Client);
            IOAuth2Token token    = null;

            while (token == null)
            {
                try
                {
                    token = await endpoint.GetTokenByRefreshTokenAsync(settings.RefreshToken);
                } catch (Exception ex)
                {
                    token = null;
                    Console.WriteLine(ex.Message);
                    await Task.Delay(5000);
                }
                break;
            }

            Client.SetOAuth2Token(token);

            Console.WriteLine("Imgur Ready.");
        }
        public void RefreshToken()
        {
            var client           = new ImgurClient(MainPage.CLIENT_ID, MainPage.CLIENT_SECRET);
            var endpoint         = new OAuth2Endpoint(client);
            var NEW_ACCESS_TOKEN = endpoint.GetTokenByRefreshTokenAsync(REFRESH_TOKEN);

            Application.Current.Properties["TOKEN_ACCESS"] = NEW_ACCESS_TOKEN;

            token = new OAuth2Token(NEW_ACCESS_TOKEN.ToString(), REFRESH_TOKEN, TOKEN_TYPE, ACCOUNT_ID, IMGUR_USER_ACCOUNT, int.Parse(EXPIRES_IN));
        }
Exemple #4
0
        public async Task <string> LoggedInUser(string refreshToken)
        {
            string username = null;

            try {
                IOAuth2Token token = await _endpoint.GetTokenByRefreshTokenAsync(refreshToken);

                username = token.AccountUsername;
            } catch { }

            return(username);
        }
        public async Task GetTokenByRefreshTokenAsync_SetToken_IsNotNull()
        {
            var authentication = new ImgurClient(ClientId, ClientSecret);
            var endpoint       = new OAuth2Endpoint(authentication);
            var token          = await endpoint.GetTokenByRefreshTokenAsync(RefreshToken);

            Assert.IsNotNull(token);
            Assert.IsFalse(string.IsNullOrWhiteSpace(token.AccessToken));
            Assert.IsFalse(string.IsNullOrWhiteSpace(token.RefreshToken));
            Assert.IsFalse(string.IsNullOrWhiteSpace(token.AccountId));
            Assert.IsFalse(string.IsNullOrWhiteSpace(token.TokenType));
        }
Exemple #6
0
        //Login to Imgur Account
        private async void Login()
        {
            try {
                OAuth2Endpoint endpoint = new OAuth2Endpoint(_client);

                string       refreshToken = FileIO.ReadRefreshToken();
                IOAuth2Token token        = await endpoint.GetTokenByRefreshTokenAsync(refreshToken);

                _client.SetOAuth2Token(token);
            } catch {
                // ignored
            }
        }
Exemple #7
0
        private IOAuth2Token GetOAuth2Token()
        {
            if (_token != null)
            {
                return(_token);
            }

            var authentication = new ImgurClient(ClientId, ClientSecret);
            var endpoint       = new OAuth2Endpoint(authentication);

            _token = endpoint.GetTokenByRefreshTokenAsync(RefreshToken).Result;
            return(_token);
        }
Exemple #8
0
        public async Task GetTokenByRefreshTokenAsync_WithTokenNull_ThrowsArgumentNullException()
        {
            var client   = new ImgurClient("123", "1234");
            var endpoint = new OAuth2Endpoint(client);

            var exception =
                await
                Record.ExceptionAsync(
                    async() => await endpoint.GetTokenByRefreshTokenAsync(null).ConfigureAwait(false))
                .ConfigureAwait(false);

            Assert.NotNull(exception);
            Assert.IsType <ArgumentNullException>(exception);
        }
Exemple #9
0
        public async Task <string> LoggedInUser(string refreshToken)
        {
            string username = null;

            try {
                IOAuth2Token token = await _endpoint.GetTokenByRefreshTokenAsync(refreshToken);

                username = token.AccountUsername;
            }
            catch {}

            UserUrl = $"http://{username}.imgur.com/all/";

            return(username);
        }
Exemple #10
0
        //Login to Imgur Account
        public async Task Login()
        {
            try {
                string refreshToken = ConfigHelper.ReadRefreshToken();
                if (string.IsNullOrWhiteSpace(refreshToken))
                {
                    return;
                }

                OAuth2Endpoint endpoint = new OAuth2Endpoint(_client);
                IOAuth2Token   token    = await endpoint.GetTokenByRefreshTokenAsync(refreshToken);

                _client.SetOAuth2Token(token);
            } catch {
                // ignored
            }
        }
Exemple #11
0
        public async Task GetTokenByRefreshTokenAsync_WithClientSecretNull_ThrowsArgumentNullException()
        {
            var client   = new ImgurClient("123");
            var endpoint = new OAuth2Endpoint(client);

            var exception =
                await
                Record.ExceptionAsync(
                    async() => await endpoint.GetTokenByRefreshTokenAsync("ahkjhkjhc").ConfigureAwait(false))
                .ConfigureAwait(false);

            Assert.NotNull(exception);
            Assert.IsType <ArgumentException>(exception);

            var argNullException = (ArgumentException)exception;

            Assert.Equal(argNullException.Message, "ApiClient.ClientSecret is required.");
        }
Exemple #12
0
        public async Task GetTokenByRefreshTokenAsync_Equal()
        {
            var mockUrl      = "https://api.imgur.com/oauth2/token";
            var mockResponse = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent(MockOAuth2EndpointResponses.GetTokenByRefreshToken)
            };

            var client   = new ImgurClient("123", "1234");
            var endpoint = new OAuth2Endpoint(client, new HttpClient(new MockHttpMessageHandler(mockUrl, mockResponse)));
            var token    = await endpoint.GetTokenByRefreshTokenAsync("xhjhjhj").ConfigureAwait(false);

            Assert.Equal("RefreshTokenResponse", token.AccessToken);
            Assert.Equal("2132d34234jkljj84ce0c16fjkljfsdfdc70", token.RefreshToken);
            Assert.Equal("bearer", token.TokenType);
            Assert.Equal(2419200, token.ExpiresIn);
            Assert.Equal("Bob", token.AccountUsername);
            Assert.Equal("45344", token.AccountId);
        }
Exemple #13
0
        public string GetToken()
        {
            // Create a parser to read the auth.ini file
            var     parser       = new FileIniDataParser();
            IniData authData     = parser.ReadFile(Environment.ExpandEnvironmentVariables("%appdata%\\ShareShot\\auth.ini"));
            string  clientId     = authData["credentials"]["client_id"];
            string  clientSecret = authData["credentials"]["client_secret"];
            string  refreshToken = authData["credentials"]["refresh_token"];

            // Get the authorization url using the clientId
            var client   = new ImgurClient(clientId, clientSecret);
            var endpoint = new OAuth2Endpoint(client);

            // Try/Catch block, in case the refresh token is null or invalid.
            try {
                return(endpoint.GetTokenByRefreshTokenAsync(refreshToken).Result.AccessToken);
            }
            catch (AggregateException) {
                return(AuthUser());
            }
        }
        public async Task GetTokenByRefreshTokenAsync_AreEqual()
        {
            var fakeHttpMessageHandler = new FakeHttpMessageHandler();
            var fakeResponse           = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent(OAuth2EndpointResponses.OAuth2TokenRefreshTokenResponse)
            };

            fakeHttpMessageHandler.AddFakeResponse(new Uri("https://api.imgur.com/oauth2/token"), fakeResponse);

            var client   = new ImgurClient("123", "1234");
            var endpoint = new OAuth2Endpoint(client, new HttpClient(fakeHttpMessageHandler));
            var token    = await endpoint.GetTokenByRefreshTokenAsync("xhjhjhj");

            Assert.AreEqual("RefreshTokenResponse", token.AccessToken);
            Assert.AreEqual("2132d34234jkljj84ce0c16fjkljfsdfdc70", token.RefreshToken);
            Assert.AreEqual("bearer", token.TokenType);
            Assert.AreEqual(2419200, token.ExpiresIn);
            Assert.AreEqual("Bob", token.AccountUsername);
            Assert.AreEqual("45344", token.AccountId);
        }
Exemple #15
0
        //Login to Imgur Account
        public async Task Login()
        {
            try {
                if (_token != null && _token.ExpiresIn > 60)
                {
                    return; // More than 60 seconds left; we don't need to login
                }
                string refreshToken = ConfigHelper.ReadRefreshToken();
                if (string.IsNullOrWhiteSpace(refreshToken)) // No refresh token found; exit
                {
                    throw new Exception("No refresh-token found!");
                }

                // Refresh access token
                OAuth2Endpoint endpoint = new OAuth2Endpoint(_client);
                _token = await endpoint.GetTokenByRefreshTokenAsync(refreshToken);

                _client.SetOAuth2Token(_token);
            } catch {
                // ignored
            }
        }
 public async Task GetTokenByRefreshTokenAsync_WithTokenNull_ThrowsArgumentNullException()
 {
     var client   = new ImgurClient("123", "1234");
     var endpoint = new OAuth2Endpoint(client);
     await endpoint.GetTokenByRefreshTokenAsync(null);
 }