public void GetAuthorization(string code)
{
if (!string.IsNullOrEmpty(code))
{
IAuthorizationState authorization = null;
authorization = Client.ProcessUserAuthorizationAsync(Request, Response.ClientDisconnectedToken);
if (authorization != null)
{
// We are receiving an authorization response. Store it and associate it with this user.
Authorization = authorization;
//Response.Redirect(Request.Path); // get rid of the /?code= parameter
Response.Redirect("/CusAuth/AuthSuccess");
}
}
if (Authorization != null)
{
foreach (var li in m_AuthItemModelList.Where(s => Authorization.Scope.Contains(s.Item)))
{
li.IsAuthed = true;
}
if (Authorization.AccessTokenExpirationUtc.HasValue)
{
TimeSpan timeLeft = Authorization.AccessTokenExpirationUtc.Value - DateTime.UtcNow;
ViewBag.ExpireTime = string.Format(CultureInfo.CurrentCulture, "(access token expires in {0} minutes)", Math.Round(timeLeft.TotalMinutes, 1));
}
}
string[] scopes = new string[] { "https://resourceserver.oauth.com/api/Person/Name", "https://resourceserver.oauth.com/api/Person/Age" };
var request = Client.PrepareRequestUserAuthorizationAsync(scopes, cancellationToken: Response.ClientDisconnectedToken);
request.SendAsync();
this.HttpContext.Response.End();
}
public async Task DecodeRefreshToken()
{
var refreshTokenSource = new TaskCompletionSource <string>();
Handle(AuthorizationServerDescription.AuthorizationEndpoint).By(
async(req, ct) => {
var server = new AuthorizationServer(AuthorizationServerMock);
var request = await server.ReadAuthorizationRequestAsync(req, ct);
Assert.That(request, Is.Not.Null);
var response = server.PrepareApproveAuthorizationRequest(request, ResourceOwnerUsername);
return(await server.Channel.PrepareResponseAsync(response));
});
Handle(AuthorizationServerDescription.TokenEndpoint).By(
async(req, ct) => {
var server = new AuthorizationServer(AuthorizationServerMock);
var response = await server.HandleTokenRequestAsync(req, ct);
var authorization = server.DecodeRefreshToken(refreshTokenSource.Task.Result);
Assert.That(authorization, Is.Not.Null);
Assert.That(authorization.User, Is.EqualTo(ResourceOwnerUsername));
return(response);
});
var client = new WebServerClient(AuthorizationServerDescription);
try {
var authState = new AuthorizationState(TestScopes)
{
Callback = ClientCallback,
};
var authRedirectResponse = await client.PrepareRequestUserAuthorizationAsync(authState);
this.HostFactories.CookieContainer.SetCookies(authRedirectResponse, ClientCallback);
Uri authCompleteUri;
using (var httpClient = this.HostFactories.CreateHttpClient()) {
using (var response = await httpClient.GetAsync(authRedirectResponse.Headers.Location)) {
response.EnsureSuccessStatusCode();
authCompleteUri = response.Headers.Location;
}
}
var authCompleteRequest = new HttpRequestMessage(HttpMethod.Get, authCompleteUri);
this.HostFactories.CookieContainer.ApplyCookies(authCompleteRequest);
var result = await client.ProcessUserAuthorizationAsync(authCompleteRequest);
Assert.That(result.AccessToken, Is.Not.Null.And.Not.Empty);
Assert.That(result.RefreshToken, Is.Not.Null.And.Not.Empty);
refreshTokenSource.SetResult(result.RefreshToken);
} catch {
refreshTokenSource.TrySetCanceled();
}
}
public async Task CreateAccessTokenSeesAuthorizingUserAuthorizationCodeGrant()
{
var authServerMock = CreateAuthorizationServerMock();
authServerMock
.Setup(a => a.IsAuthorizationValid(It.IsAny <IAuthorizationDescription>()))
.Returns <IAuthorizationDescription>(req => {
Assert.That(req.User, Is.EqualTo(ResourceOwnerUsername));
return(true);
});
Handle(AuthorizationServerDescription.AuthorizationEndpoint).By(
async(req, ct) => {
var server = new AuthorizationServer(authServerMock.Object);
var request = await server.ReadAuthorizationRequestAsync(req, ct);
Assert.That(request, Is.Not.Null);
var response = server.PrepareApproveAuthorizationRequest(request, ResourceOwnerUsername);
return(await server.Channel.PrepareResponseAsync(response));
});
Handle(AuthorizationServerDescription.TokenEndpoint).By(
async(req, ct) => {
var server = new AuthorizationServer(authServerMock.Object);
return(await server.HandleTokenRequestAsync(req, ct));
});
var client = new WebServerClient(AuthorizationServerDescription, ClientId, ClientSecret, this.HostFactories);
var authState = new AuthorizationState(TestScopes)
{
Callback = ClientCallback,
};
var authRedirectResponse = await client.PrepareRequestUserAuthorizationAsync(authState);
this.HostFactories.CookieContainer.SetCookies(authRedirectResponse, ClientCallback);
Uri authCompleteUri;
this.HostFactories.AllowAutoRedirects = false;
using (var httpClient = this.HostFactories.CreateHttpClient()) {
using (var response = await httpClient.GetAsync(authRedirectResponse.Headers.Location)) {
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Redirect));
authCompleteUri = response.Headers.Location;
}
}
var authCompleteRequest = new HttpRequestMessage(HttpMethod.Get, authCompleteUri);
this.HostFactories.CookieContainer.ApplyCookies(authCompleteRequest);
var result = await client.ProcessUserAuthorizationAsync(authCompleteRequest);
Assert.That(result.AccessToken, Is.Not.Null.And.Not.Empty);
Assert.That(result.RefreshToken, Is.Not.Null.And.Not.Empty);
}
protected void getAuthorizationButton_Click(object sender, EventArgs e)
{
this.RegisterAsyncTask(
new PageAsyncTask(
async ct => {
string[] scopes =
(from item in this.scopeList.Items.OfType <ListItem>() where item.Selected select item.Value).ToArray();
var request =
await Client.PrepareRequestUserAuthorizationAsync(scopes, cancellationToken: Response.ClientDisconnectedToken);
await request.SendAsync();
this.Context.Response.End();
}));
}
public Task <HttpResponseMessage> GetRedirectResponse(Uri returnUrl)
{
return(_client.PrepareRequestUserAuthorizationAsync(new[] { _emailScope }, returnUrl));
}
