merged

Author: davidgrupp

Backup/RestSharp.Silverlight/Authenticators/HttpBasicAuthenticator.cs

@@ -0,0 +1,50 @@
+#region License
+//   Copyright 2010 John Sheehan
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License. 
+#endregion
+
+using System;
+using System.Linq;
+using System.Text;
+
+namespace RestSharp
+{
+	public class HttpBasicAuthenticator : IAuthenticator
+	{
+		private readonly string _username;
+		private readonly string _password;
+
+		public HttpBasicAuthenticator(string username, string password) {
+			_password = password;
+			_username = username;
+		}
+
+		public void Authenticate(IRestClient client, IRestRequest request) {
+			// NetworkCredentials always makes two trips, even if with PreAuthenticate,
+			// it is also unsafe for many partial trust scenarios
+			// request.Credentials = Credentials;
+			// thanks TweetSharp!
+
+			// request.Credentials = new NetworkCredential(_username, _password);
+
+			// only add the Authorization parameter if it hasn't been added by a previous Execute
+			if (!request.Parameters.Any(p => p.Name.Equals("Authorization", StringComparison.OrdinalIgnoreCase)))
+			{
+				var token = Convert.ToBase64String(Encoding.UTF8.GetBytes(string.Format("{0}:{1}", _username, _password)));
+				var authHeader = string.Format("Basic {0}", token);
+				request.AddParameter("Authorization", authHeader, ParameterType.HttpHeader);
+			}
+		}
+	}
+}

Backup/RestSharp.Silverlight/Authenticators/IAuthenticator.cs

@@ -0,0 +1,23 @@
+#region License
+//   Copyright 2010 John Sheehan
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License. 
+#endregion
+
+namespace RestSharp
+{
+	public interface IAuthenticator
+	{
+		void Authenticate(IRestClient client, IRestRequest request);
+	}
+}

Backup/RestSharp.Silverlight/Authenticators/NtlmAuthenticator.cs

@@ -0,0 +1,65 @@
+#region License
+//   Copyright 2010 John Sheehan
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License. 
+#endregion
+
+using System;
+using System.Net;
+
+#if FRAMEWORK
+
+namespace RestSharp
+{
+	/// <summary>
+	/// Tries to Authenticate with the credentials of the currently logged in user, or impersonate a user
+	/// </summary>
+	public class NtlmAuthenticator : IAuthenticator
+	{
+		private readonly ICredentials credentials;
+
+		/// <summary>
+		/// Authenticate with the credentials of the currently logged in user
+		/// </summary>
+		public NtlmAuthenticator()
+			: this(CredentialCache.DefaultCredentials)
+		{
+		}
+
+		/// <summary>
+		/// Authenticate by impersonation
+		/// </summary>
+		/// <param name="username"></param>
+		/// <param name="password"></param>
+		public NtlmAuthenticator(string username, string password) : this(new NetworkCredential(username, password))
+		{
+		}	
+
+		/// <summary>
+		/// Authenticate by impersonation, using an existing <c>ICredentials</c> instance
+		/// </summary>
+		/// <param name="credentials"></param>
+		public NtlmAuthenticator(ICredentials credentials)
+		{
+			if (credentials == null) throw new ArgumentNullException("credentials");
+				this.credentials = credentials;
+		}
+
+		public void Authenticate(IRestClient client, IRestRequest request)
+		{
+			request.Credentials = credentials;
+		}
+	}
+}
+
+#endif

Backup/RestSharp.Silverlight/Authenticators/OAuth/Extensions/CollectionExtensions.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Text;
+
+namespace RestSharp.Authenticators.OAuth.Extensions
+{
+	internal static class CollectionExtensions
+	{
+		public static IEnumerable<T> AsEnumerable<T>(this T item)
+		{
+			return new[] {item};
+		}
+
+		public static IEnumerable<T> And<T>(this T item, T other)
+		{
+			return new[] {item, other};
+		}
+
+		public static IEnumerable<T> And<T>(this IEnumerable<T> items, T item)
+		{
+			foreach (var i in items)
+			{
+				yield return i;
+			}
+
+			yield return item;
+		}
+
+		public static K TryWithKey<T, K>(this IDictionary<T, K> dictionary, T key)
+		{
+			return dictionary.ContainsKey(key) ? dictionary[key] : default(K);
+		}
+
+		public static IEnumerable<T> ToEnumerable<T>(this object[] items) where T : class
+		{
+			foreach (var item in items)
+			{
+				var record = item as T;
+				yield return record;
+			}
+		}
+
+		public static void ForEach<T>(this IEnumerable<T> items, Action<T> action)
+		{
+			foreach (var item in items)
+			{
+				action(item);
+			}
+		}
+
+#if !WINDOWS_PHONE && !SILVERLIGHT && !PocketPC
+
+		public static void AddRange(this IDictionary<string, string> collection, NameValueCollection range)
+		{
+			foreach (var key in range.AllKeys)
+			{
+				collection.Add(key, range[key]);
+			}
+		}
+
+		public static string ToQueryString(this NameValueCollection collection)
+		{
+			var sb = new StringBuilder();
+			if (collection.Count > 0)
+			{
+				sb.Append("?");
+			}
+
+			var count = 0;
+			foreach (var key in collection.AllKeys)
+			{
+				sb.AppendFormat("{0}={1}", key, collection[key].UrlEncode());
+				count++;
+
+				if (count >= collection.Count)
+				{
+					continue;
+				}
+				sb.Append("&");
+			}
+			return sb.ToString();
+		}
+
+#endif
+
+		public static string Concatenate(this WebParameterCollection collection, string separator, string spacer)
+		{
+			var sb = new StringBuilder();
+
+			var total = collection.Count;
+			var count = 0;
+
+			foreach (var item in collection)
+			{
+				sb.Append(item.Name);
+				sb.Append(separator);
+				sb.Append(item.Value);
+
+				count++;
+				if (count < total)
+				{
+					sb.Append(spacer);
+				}
+			}
+
+			return sb.ToString();
+		}
+	}
+}

Backup/RestSharp.Silverlight/Authenticators/OAuth/Extensions/OAuthExtensions.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace RestSharp.Authenticators.OAuth.Extensions
+{
+	internal static class OAuthExtensions
+	{
+		public static string ToRequestValue(this OAuthSignatureMethod signatureMethod)
+		{
+			var value = signatureMethod.ToString().ToUpper();
+			var shaIndex = value.IndexOf("SHA1");
+			return shaIndex > -1 ? value.Insert(shaIndex, "-") : value;
+		}
+
+		public static OAuthSignatureMethod FromRequestValue(this string signatureMethod)
+		{
+			switch (signatureMethod)
+			{
+				case "HMAC-SHA1":
+					return OAuthSignatureMethod.HmacSha1;
+				case "RSA-SHA1":
+					return OAuthSignatureMethod.RsaSha1;
+				default:
+					return OAuthSignatureMethod.PlainText;
+			}
+		}
+
+		public static string HashWith(this string input, HashAlgorithm algorithm)
+		{
+			var data = Encoding.UTF8.GetBytes(input);
+			var hash = algorithm.ComputeHash(data);
+			return Convert.ToBase64String(hash);
+		}
+	}
+}