internal async Task <TwitterClient> StartListener()
{
using (var listener = new HttpListener())
{
listener.Prefixes.Add("http://localhost:5001/validateTwitterAuth/");
listener.Start();
for (; ;)
{
HttpListenerContext context = listener.GetContext();
HttpListenerRequest request = context.Request;
using (HttpListenerResponse response = context.Response)
{
var appClient = new TwitterClient(Environment.GetEnvironmentVariable("CONSUMER_KEY"), Environment.GetEnvironmentVariable("CONSUMER_SECRET"));
// Extract the information from the redirection url
var requestParameters = await RequestCredentialsParameters.FromCallbackUrlAsync(context.Request.Url.Query, _myAuthRequestStore);
// Request Twitter to generate the credentials.
var userCreds = await appClient.Auth.RequestCredentialsAsync(requestParameters);
// Congratulations the user is now authenticated!
var userClient = new TwitterClient(userCreds);
return(userClient);
}
}
}
}
public async Task <RedirectResult> OnGet()
{
var appClient = new TwitterClient(TwitifyController.ConsumerKey, TwitifyController.ConsumerSecret);
// Extract the information from the redirection url
var requestParameters = await RequestCredentialsParameters.FromCallbackUrlAsync(Request.QueryString.Value, TwitifyController._myAuthRequestStore);
// Request Twitter to generate the credentials.
var userCreds = await appClient.Auth.RequestCredentialsAsync(requestParameters);
Response.Cookies.Append("AccessToken", userCreds.AccessToken);
Response.Cookies.Append("AccessTokenSecret", userCreds.AccessTokenSecret);
// Congratulations the user is now authenticated!
var userClient = new TwitterClient(userCreds);
var user = await userClient.Users.GetAuthenticatedUserAsync();
Response.Cookies.Append("Bio", userClient.Users.GetAuthenticatedUserAsync().Result.Description);
Response.Cookies.Append("UserName", userClient.Users.GetAuthenticatedUserAsync().Result.ScreenName);
Response.Cookies.Append("Profile", userClient.Users.GetAuthenticatedUserAsync().Result.ProfileImageUrl400x400);
Uri baseUri = TwitifyController.SpotifyUri;
var loginRequest = new LoginRequest(baseUri, TwitifyController.clientId, LoginRequest.ResponseType.Token)
{
Scope = new[] { Scopes.UserReadPlaybackState, Scopes.UserReadEmail, Scopes.UserReadCurrentlyPlaying }
};
return(Redirect(loginRequest.ToUri().ToString()));
}
public async Task RequestCredentials_ParsesTheTwitterResultAndReturnsCredentialsAsync()
{
// Arrange
var controller = CreateAuthController();
var request = A.Fake <ITwitterRequest>();
var expectedResult = A.Fake <ITwitterResult>();
var parameters = new RequestCredentialsParameters("verifier_code", new AuthenticationRequest
{
ConsumerKey = "consumer_key",
ConsumerSecret = "consumer_secret"
});
var response = "oauth_token=access_token&oauth_token_secret=access_secret";
A.CallTo(() => _fakeAuthQueryExecutor.RequestCredentialsAsync(parameters, request)).Returns(expectedResult);
A.CallTo(() => expectedResult.Content).Returns(response);
// Act
var result = await controller.RequestCredentialsAsync(parameters, request);
// Assert
Assert.Equal(result.Model.AccessToken, $"access_token");
Assert.Equal(result.Model.AccessTokenSecret, $"access_secret");
Assert.Equal(result.Model.ConsumerKey, $"consumer_key");
Assert.Equal(result.Model.ConsumerSecret, $"consumer_secret");
}
public void GetRequestCredentialsQuery_ReturnsExpectedQuery()
{
// arrange
var queryGenerator = CreateQueryGenerator();
var parameters = new RequestCredentialsParameters("verifier_code", new AuthenticationRequest())
{
CustomQueryParameters = { new Tuple <string, string>("hello", "world") }
};
// act
var result = queryGenerator.GetRequestCredentialsQuery(parameters);
// assert
Assert.Equal(result, $"https://api.twitter.com/oauth/access_token?hello=world");
}
public async Task <ActionResult> ValidateTwitterAuth()
{
var appClient = GetAppClient();
// RequestCredentialsParameters.FromCallbackUrl does 3 things:
// * Extract the id from the callback
// * Get the AuthenticationRequest from the store
// * Remove the request from the store as it will no longer need it
// This logic can be implemented manually if you wish change the behaviour
var requestParameters = await RequestCredentialsParameters.FromCallbackUrlAsync(Request.QueryString.Value, _myAuthRequestStore);
var userCreds = await appClient.Auth.RequestCredentialsAsync(requestParameters);
var userClient = new TwitterClient(userCreds);
var user = await userClient.Users.GetAuthenticatedUserAsync();
ViewBag.User = user;
return(View());
}
public async Task RequestCredentials_ThrowsWhenCredentialsAreMissingInResultAsync()
{
// Arrange
var controller = CreateAuthController();
var request = A.Fake <ITwitterRequest>();
var expectedResult = A.Fake <ITwitterResult>();
var parameters = new RequestCredentialsParameters("verifier_code", new AuthenticationRequest
{
ConsumerKey = "consumer_key",
ConsumerSecret = "consumer_secret"
});
var response = "oauth_token=access_token"; // missing secret
A.CallTo(() => _fakeAuthQueryExecutor.RequestCredentialsAsync(parameters, request)).Returns(expectedResult);
A.CallTo(() => expectedResult.Content).Returns(response);
// Act
await Assert.ThrowsAsync <TwitterAuthException>(() => controller.RequestCredentialsAsync(parameters, request));
}
public Task <ITwitterCredentials> RequestCredentialsFromCallbackUrlAsync(Uri callbackUri, IAuthenticationRequest authenticationRequest)
{
return(RequestCredentialsAsync(RequestCredentialsParameters.FromCallbackUrl(callbackUri, authenticationRequest)));
}
public Task <ITwitterCredentials> RequestCredentialsFromCallbackUrl(string callbackUrl, IAuthenticationRequest authenticationRequest)
{
return(RequestCredentials(RequestCredentialsParameters.FromCallbackUrl(callbackUrl, authenticationRequest)));
}
public static async Task <IActionResult> ValidateTwitterAuth(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req,
ILogger log)
{
try
{
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
TweetRequest tweet = JsonSerializer.Deserialize <TweetRequest>(requestBody);
if (tweet.MediaId == null || tweet.MediaId.Length == 0)
{
return(ErrorResponse.InternalServerError(detail: "No Image Data", success: false));
}
if (string.IsNullOrEmpty(tweet.OAuthToken) || string.IsNullOrEmpty(tweet.OAuthTokenSecret) || string.IsNullOrEmpty(tweet.OAuthVerifier))
{
return(ErrorResponse.InternalServerError(detail: "No Tokens Supplied", success: false));
}
var appClient = new TwitterClient(Environment.GetEnvironmentVariable("TwitterConsumerKey"), Environment.GetEnvironmentVariable("TwitterConsumerSecret"));
RequestCredentialsParameters requestParameters = new RequestCredentialsParameters(tweet.OAuthVerifier, new AuthenticationRequest
{
ConsumerKey = Environment.GetEnvironmentVariable("TwitterConsumerKey"),
ConsumerSecret = Environment.GetEnvironmentVariable("TwitterConsumerSecret"),
AuthorizationKey = tweet.OAuthToken,
AuthorizationSecret = tweet.OAuthTokenSecret,
VerifierCode = null,
AuthorizationURL = $"{Environment.GetEnvironmentVariable("TwitterAuthorizationUrl")}={tweet.OAuthToken}"
});
ITwitterCredentials userCreds;
TwitterClient userClient;
try
{
userCreds = await appClient.Auth.RequestCredentialsAsync(requestParameters);
userClient = new TwitterClient(userCreds);
var user = await userClient.Users.GetAuthenticatedUserAsync();
}
catch (Exception ex)
{
log.LogError(ex.Message);
return(ErrorResponse.InternalServerError(detail: "oAuth Fail", success: false));
}
var uploadedImage = await userClient.Upload.UploadTweetImageAsync(tweet.MediaId);
await userClient.Upload.AddMediaMetadataAsync(new MediaMetadata(uploadedImage)
{
AltText = "My .NET Bot",
});
var tweetWithImage = await userClient.Tweets.PublishTweetAsync(new PublishTweetParameters(tweet.TweetText)
{
Medias = { uploadedImage }
});
var tweetResponse = new TweetResponse
{
Success = true
};
return(new OkObjectResult(tweetResponse));
}
catch (Exception ex)
{
log.LogError(ex.Message);
return(ErrorResponse.InternalServerError(detail: "Posting Issue", success: false));
}
}
public override LoginProfile ProcessAuthoriztion(HttpContext context, IDictionary <string, string> @params)
{
if (!string.IsNullOrEmpty(context.Request["denied"]))
{
return(LoginProfile.FromError(new Exception("Canceled at provider")));
}
var appClient = new TwitterClient(TwitterKey, TwitterSecret);
if (string.IsNullOrEmpty(context.Request["oauth_token"]))
{
var callbackAddress = new UriBuilder(RedirectUri)
{
Query = "state=" + HttpUtility.UrlEncode(context.Request.GetUrlRewriter().AbsoluteUri)
};
var authenticationRequestId = Guid.NewGuid().ToString();
// Add the user identifier as a query parameters that will be received by `ValidateTwitterAuth`
var redirectURL = _myAuthRequestStore.AppendAuthenticationRequestIdToCallbackUrl(callbackAddress.ToString(), authenticationRequestId);
// Initialize the authentication process
var authenticationRequestToken = appClient.Auth.RequestAuthenticationUrlAsync(redirectURL)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
// Store the token information in the store
_myAuthRequestStore.AddAuthenticationTokenAsync(authenticationRequestId, authenticationRequestToken)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
context.Response.Redirect(authenticationRequestToken.AuthorizationURL, true);
return(null);
}
// Extract the information from the redirection url
var requestParameters = RequestCredentialsParameters.FromCallbackUrlAsync(context.Request.RawUrl, _myAuthRequestStore).GetAwaiter().GetResult();
// Request Twitter to generate the credentials.
var userCreds = appClient.Auth.RequestCredentialsAsync(requestParameters)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
// Congratulations the user is now authenticated!
var userClient = new TwitterClient(userCreds);
var user = userClient.Users.GetAuthenticatedUserAsync()
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
var userSettings = userClient.AccountSettings.GetAccountSettingsAsync()
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
return(user == null
? null
: new LoginProfile
{
Name = user.Name,
DisplayName = user.ScreenName,
Avatar = user.ProfileImageUrl,
Locale = userSettings.Language.ToString(),
Id = user.Id.ToString(CultureInfo.InvariantCulture),
Provider = ProviderConstants.Twitter
});
}
