private string CallService(string url)
{
if (Authorization == null)
{
throw new InvalidOperationException("No access token!");
}
if (Authorization.AccessTokenExpirationUtc.HasValue)
{
// 刷新access token
Client.RefreshAuthorizationAsync(Authorization, TimeSpan.FromSeconds(30));
}
var httpRequest = (HttpWebRequest)WebRequest.Create(url);
ClientBase.AuthorizeRequest(httpRequest, Authorization.AccessToken);
var response = httpRequest.GetResponse();
string result = "";
using (StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
{
result = reader.ReadToEnd();
}
return(result);
}
public override void ApplyAuthenticationToRequest(HttpWebRequest request)
{
base.ApplyAuthenticationToRequest(request);
// Populate the AuthorizationState with an access token.
LoadAccessToken();
try
{
if (State != null && !string.IsNullOrEmpty(State.AccessToken))
{
// Apply authorization to the current request
if (string.IsNullOrEmpty(State.RefreshToken))
{
ClientBase.AuthorizeRequest(request, State.AccessToken);
}
else
{
// This only works if State has a refresh token
tokenProvider.AuthorizeRequest(request, State);
}
}
}
finally
{
if (NoCaching)
{
State = null;
}
}
}
public void ApplyAuthenticationToRequest(HttpWebRequest request)
{
// Turn off Expect100Continue behavior. For web method calls it is not used
// and many servers reject the request if this is present on PUT or POST
// requests with a body present. If used, Expect100Continue prevents the client
// from sending the request body unless the server approves the request by sending
// Expect100Continue.
request.ServicePoint.Expect100Continue = false;
// Populate the AuthorizationState with an access token.
LoadAccessToken();
try
{
if (State != null && !string.IsNullOrEmpty(State.AccessToken))
{
// Apply authorization to the current request
if (string.IsNullOrEmpty(State.RefreshToken))
{
ClientBase.AuthorizeRequest(request, State.AccessToken);
}
else
{
// This only works if State has a refresh token
tokenProvider.AuthorizeRequest(request, State);
}
}
}
finally
{
if (NoCaching)
{
State = null;
}
}
}
private void getResourceButton_Click(object sender, EventArgs e)
{
var sb = new StringBuilder();
// Create the ServiceStack API client and the request DTO
var apiClient = new JsonServiceClient(resourceUriTextBox.Text);
var apiRequestDto = new Users {
Username = usernameTextBox.Text
};
// Wire up the ServiceStack client filter so that DotNetOpenAuth can
// add the authorization header before the request is sent
// to the API server
apiClient.LocalHttpWebRequestFilter = request => {
// This is the magic line that makes all the client-side magic work :)
ClientBase.AuthorizeRequest(request, accessTokenTextBox.Text);
LogStuff(request, sb);
};
// This filter is used only for logging the response output. The code will work without it.
apiClient.LocalHttpWebResponseFilter += response => LogStuff(response, sb);
try {
// Send the API request and dump the response to our output TextBox
var response = apiClient.Get(apiRequestDto);
LogStuff(response, sb);
} catch (WebServiceException ex) {
sb.AppendLine(ex.Dump());
sb.AppendLine(ex.ResponseBody.Replace(" at ", Environment.NewLine + " at "));
} catch (Exception ex) {
sb.AppendLine(ex.Message);
}
outputTextBox.Text = sb.ToString();
}
private async Task <T> CallServiceAsync <T>(Func <DataApiClient, T> predicate, CancellationToken cancellationToken)
{
if (Authorization == null)
{
throw new InvalidOperationException("No access token!");
}
var wcfClient = new DataApiClient();
// Refresh the access token if it expires and if its lifetime is too short to be of use.
if (Authorization.AccessTokenExpirationUtc.HasValue)
{
if (await Client.RefreshAuthorizationAsync(Authorization, TimeSpan.FromSeconds(30)))
{
TimeSpan timeLeft = Authorization.AccessTokenExpirationUtc.Value - DateTime.UtcNow;
this.authorizationLabel.Text += string.Format(CultureInfo.CurrentCulture, " - just renewed for {0} more minutes)", Math.Round(timeLeft.TotalMinutes, 1));
}
}
var httpRequest = (HttpWebRequest)WebRequest.Create(wcfClient.Endpoint.Address.Uri);
ClientBase.AuthorizeRequest(httpRequest, Authorization.AccessToken);
var httpDetails = new HttpRequestMessageProperty();
httpDetails.Headers[HttpRequestHeader.Authorization] = httpRequest.Headers[HttpRequestHeader.Authorization];
using (var scope = new OperationContextScope(wcfClient.InnerChannel)) {
OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = httpDetails;
return(predicate(wcfClient));
}
}
protected async void Button1_Click(object sender, EventArgs e)
{
var authServer = new AuthorizationServerDescription()
{
TokenEndpoint = new Uri("http://localhost:53022/OAuth/token "),
ProtocolVersion = ProtocolVersion.V20
};
WebServerClient Client = new WebServerClient(authServer, "idefav", "1");
var code = await Client.GetClientAccessTokenAsync(new string[] { "http://localhost:55045/IService1/DoWork" });
string token = code.AccessToken;
Service1Reference.Service1Client service1Client = new Service1Client();
var httpRequest = (HttpWebRequest)WebRequest.Create(service1Client.Endpoint.Address.Uri);
ClientBase.AuthorizeRequest(httpRequest, token);
var httpDetails = new HttpRequestMessageProperty();
httpDetails.Headers[HttpRequestHeader.Authorization] = httpRequest.Headers[HttpRequestHeader.Authorization];
using (var scope = new OperationContextScope(service1Client.InnerChannel))
{
if (OperationContext.Current.OutgoingMessageProperties.ContainsKey(HttpRequestMessageProperty.Name))
{
OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = httpDetails;
}
else
{
OperationContext.Current.OutgoingMessageProperties.Add(HttpRequestMessageProperty.Name, httpDetails);
}
Button1.Text = service1Client.DoWork();
}
}
/// <summary>
/// Request the resource data from the web service instance. (Places the access token into the request header).
/// </summary>
/// <typeparam name="T">The return type of the service method.</typeparam>
/// <typeparam name="TService">The web service type.</typeparam>
/// <typeparam name="TServiceChannel">The web service interface channel.</typeparam>
/// <param name="state">Provides access to a persistent object that tracks the state of an authorization.</param>
/// <param name="resourceEndPointUrl">The resource endpoint url.</param>
/// <param name="serviceInstance">The instance of the web service client.</param>
/// <param name="predicate">The web service method action to execute.</param>
/// <returns>The type of data to return from the action execution.</returns>
public virtual T RequestResourceFromService <T, TService, TServiceChannel>(IAuthorizationState state, string resourceEndPointUrl, TService serviceInstance, Func <TService, T> predicate)
where TService : ClientBase <TServiceChannel>
where TServiceChannel : class
{
if (state == null)
{
throw new ArgumentNullException("state");
}
if (String.IsNullOrEmpty(resourceEndPointUrl))
{
throw new ArgumentNullException("resourceEndPointUrl");
}
if (serviceInstance == null)
{
throw new ArgumentNullException("serviceInstance");
}
if (predicate == null)
{
throw new ArgumentNullException("predicate");
}
// Create a new http request and add the access token
// to the headers of the request.
System.Net.HttpWebRequest httpRequest = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(resourceEndPointUrl);
ClientBase.AuthorizeRequest(httpRequest, state.AccessToken);
// Add the headers of the request including the access token to the request details.
HttpRequestMessageProperty httpDetails = new HttpRequestMessageProperty();
httpDetails.Headers[HttpRequestHeader.Authorization] = httpRequest.Headers[HttpRequestHeader.Authorization];
// Create a new service scope context.
using (OperationContextScope scope = new OperationContextScope(serviceInstance.InnerChannel))
{
// Add the headers including the access token
// to the headers of the outgoing web service message.
OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = httpDetails;
// Execute the web service method action.
return(predicate(serviceInstance));
}
}