Moved all the OAuth classes into its own namespace in preparation to receiving DotNetOpenId merge.

1 files changed, 176 insertions, 0 deletions

diff --git a/src/DotNetOAuth/OAuth/ConsumerBase.cs b/src/DotNetOAuth/OAuth/ConsumerBase.cs
new file mode 100644
index 0000000..6b3a4b9
--- /dev/null
+++ b/src/DotNetOAuth/OAuth/ConsumerBase.cs
@@ -0,0 +1,176 @@
+//-----------------------------------------------------------------------

+// <copyright file="ConsumerBase.cs" company="Andrew Arnott">

+//     Copyright (c) Andrew Arnott. All rights reserved.

+// </copyright>

+//-----------------------------------------------------------------------

+

+namespace DotNetOAuth.OAuth {

+	using System;

+	using System.Collections.Generic;

+	using System.Diagnostics.CodeAnalysis;

+	using System.Net;

+	using DotNetOAuth.Messaging;

+	using DotNetOAuth.Messaging.Bindings;

+	using DotNetOAuth.OAuth.ChannelElements;

+	using DotNetOAuth.OAuth.Messages;

+

+	/// <summary>

+	/// Base class for <see cref="WebConsumer"/> and <see cref="DesktopConsumer"/> types.

+	/// </summary>

+	public class ConsumerBase {

+		/// <summary>

+		/// Initializes a new instance of the <see cref="ConsumerBase"/> class.

+		/// </summary>

+		/// <param name="serviceDescription">The endpoints and behavior of the Service Provider.</param>

+		/// <param name="tokenManager">The host's method of storing and recalling tokens and secrets.</param>

+		protected ConsumerBase(ServiceProviderDescription serviceDescription, ITokenManager tokenManager) {

+			if (serviceDescription == null) {

+				throw new ArgumentNullException("serviceDescription");

+			}

+			if (tokenManager == null) {

+				throw new ArgumentNullException("tokenManager");

+			}

+

+			this.WebRequestHandler = new StandardWebRequestHandler();

+			ITamperProtectionChannelBindingElement signingElement = serviceDescription.CreateTamperProtectionElement();

+			INonceStore store = new NonceMemoryStore(StandardExpirationBindingElement.DefaultMaximumMessageAge);

+			this.OAuthChannel = new OAuthChannel(signingElement, store, tokenManager, new OAuthConsumerMessageTypeProvider(), this.WebRequestHandler);

+			this.ServiceProvider = serviceDescription;

+		}

+

+		/// <summary>

+		/// Gets or sets the Consumer Key used to communicate with the Service Provider.

+		/// </summary>

+		public string ConsumerKey { get; set; }

+

+		/// <summary>

+		/// Gets the Service Provider that will be accessed.

+		/// </summary>

+		public ServiceProviderDescription ServiceProvider { get; private set; }

+

+		/// <summary>

+		/// Gets the persistence store for tokens and secrets.

+		/// </summary>

+		public ITokenManager TokenManager {

+			get { return this.OAuthChannel.TokenManager; }

+		}

+

+		/// <summary>

+		/// Gets the channel to use for sending/receiving messages.

+		/// </summary>

+		public Channel Channel {

+			get { return this.OAuthChannel; }

+		}

+

+		/// <summary>

+		/// Gets or sets the channel to use for sending/receiving messages.

+		/// </summary>

+		internal OAuthChannel OAuthChannel { get; set; }

+

+		/// <summary>

+		/// Gets or sets the object that processes <see cref="HttpWebRequest"/>s.

+		/// </summary>

+		/// <remarks>

+		/// This defaults to a straightforward implementation, but can be set

+		/// to a mock object for testing purposes.

+		/// </remarks>

+		internal IWebRequestHandler WebRequestHandler { get; set; }

+

+		/// <summary>

+		/// Creates a web request prepared with OAuth authorization 

+		/// that may be further tailored by adding parameters by the caller.

+		/// </summary>

+		/// <param name="endpoint">The URL and method on the Service Provider to send the request to.</param>

+		/// <param name="accessToken">The access token that permits access to the protected resource.</param>

+		/// <returns>The initialized WebRequest object.</returns>

+		public WebRequest PrepareAuthorizedRequest(MessageReceivingEndpoint endpoint, string accessToken) {

+			IDirectedProtocolMessage message = this.CreateAuthorizingMessage(endpoint, accessToken);

+			HttpWebRequest wr = this.OAuthChannel.InitializeRequest(message);

+			return wr;

+		}

+

+		/// <summary>

+		/// Creates a web request prepared with OAuth authorization 

+		/// that may be further tailored by adding parameters by the caller.

+		/// </summary>

+		/// <param name="endpoint">The URL and method on the Service Provider to send the request to.</param>

+		/// <param name="accessToken">The access token that permits access to the protected resource.</param>

+		/// <returns>The initialized WebRequest object.</returns>

+		/// <exception cref="WebException">Thrown if the request fails for any reason after it is sent to the Service Provider.</exception>

+		public Response PrepareAuthorizedRequestAndSend(MessageReceivingEndpoint endpoint, string accessToken) {

+			IDirectedProtocolMessage message = this.CreateAuthorizingMessage(endpoint, accessToken);

+			HttpWebRequest wr = this.OAuthChannel.InitializeRequest(message);

+			return this.WebRequestHandler.GetResponse(wr);

+		}

+

+		/// <summary>

+		/// Prepares an OAuth message that begins an authorization request that will 

+		/// redirect the user to the Service Provider to provide that authorization.

+		/// </summary>

+		/// <param name="callback">

+		/// An optional Consumer URL that the Service Provider should redirect the 

+		/// User Agent to upon successful authorization.

+		/// </param>

+		/// <param name="requestParameters">Extra parameters to add to the request token message.  Optional.</param>

+		/// <param name="redirectParameters">Extra parameters to add to the redirect to Service Provider message.  Optional.</param>

+		/// <param name="requestToken">The request token that must be exchanged for an access token after the user has provided authorization.</param>

+		/// <returns>The pending user agent redirect based message to be sent as an HttpResponse.</returns>

+		[SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", MessageId = "3#", Justification = "Two results")]

+		protected internal UserAuthorizationRequest PrepareRequestUserAuthorization(Uri callback, IDictionary<string, string> requestParameters, IDictionary<string, string> redirectParameters, out string requestToken) {

+			// Obtain an unauthorized request token.

+			var token = new UnauthorizedTokenRequest(this.ServiceProvider.RequestTokenEndpoint) {

+				ConsumerKey = this.ConsumerKey,

+			};

+			token.AddNonOAuthParameters(requestParameters);

+			var requestTokenResponse = this.Channel.Request<UnauthorizedTokenResponse>(token);

+			this.TokenManager.StoreNewRequestToken(token, requestTokenResponse);

+

+			// Request user authorization.

+			ITokenContainingMessage assignedRequestToken = requestTokenResponse;

+			var requestAuthorization = new UserAuthorizationRequest(this.ServiceProvider.UserAuthorizationEndpoint, assignedRequestToken.Token) {

+				Callback = callback,

+			};

+			requestAuthorization.AddNonOAuthParameters(redirectParameters);

+			requestToken = requestAuthorization.RequestToken;

+			return requestAuthorization;

+		}

+

+		/// <summary>

+		/// Creates a web request prepared with OAuth authorization 

+		/// that may be further tailored by adding parameters by the caller.

+		/// </summary>

+		/// <param name="endpoint">The URL and method on the Service Provider to send the request to.</param>

+		/// <param name="accessToken">The access token that permits access to the protected resource.</param>

+		/// <returns>The initialized WebRequest object.</returns>

+		protected internal AccessProtectedResourceRequest CreateAuthorizingMessage(MessageReceivingEndpoint endpoint, string accessToken) {

+			if (endpoint == null) {

+				throw new ArgumentNullException("endpoint");

+			}

+			if (String.IsNullOrEmpty(accessToken)) {

+				throw new ArgumentNullException("accessToken");

+			}

+

+			AccessProtectedResourceRequest message = new AccessProtectedResourceRequest(endpoint) {

+				AccessToken = accessToken,

+				ConsumerKey = this.ConsumerKey,

+			};

+

+			return message;

+		}

+

+		/// <summary>

+		/// Exchanges a given request token for access token.

+		/// </summary>

+		/// <param name="requestToken">The request token that the user has authorized.</param>

+		/// <returns>The access token assigned by the Service Provider.</returns>

+		protected AuthorizedTokenResponse ProcessUserAuthorization(string requestToken) {

+			var requestAccess = new AuthorizedTokenRequest(this.ServiceProvider.AccessTokenEndpoint) {

+				RequestToken = requestToken,

+				ConsumerKey = this.ConsumerKey,

+			};

+			var grantAccess = this.Channel.Request<AuthorizedTokenResponse>(requestAccess);

+			this.TokenManager.ExpireRequestTokenAndStoreNewAccessToken(this.ConsumerKey, requestToken, grantAccess.AccessToken, grantAccess.TokenSecret);

+			return grantAccess;

+		}

+	}

+}