Merge pull request #1 from BrianFarnhill/master

Addded OAuth1 support

Author: Devin Rader

RestSharp.WinRT/Authenticators/OAuth/Extensions/CollectionExtensions.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+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
+        {
+            return items.Select(item => item as T);
+        }
+
+        public static void ForEach<T>(this IEnumerable<T> items, Action<T> action)
+        {
+            foreach (var item in items)
+            {
+                action(item);
+            }
+        }
+
+#if !WINDOWS_PHONE && !SILVERLIGHT
+
+        public static void AddRange(this IDictionary<string, string> collection, Dictionary<string, string> range)
+        {
+            foreach (var key in range.Keys)
+            {
+                collection.Add(key, range[key]);
+            }
+        }
+
+        public static string ToQueryString(this Dictionary<string, string> collection)
+        {
+            var sb = new StringBuilder();
+            if (collection.Count > 0)
+            {
+                sb.Append("?");
+            }
+
+            var count = 0;
+            foreach (var key in collection.Keys)
+            {
+                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();
+        }
+    }
+}

RestSharp.WinRT/Authenticators/OAuth/Extensions/OAuthExtensions.cs

@@ -0,0 +1,25 @@
+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;
+            }
+        }
+    }
+}

RestSharp.WinRT/Authenticators/OAuth/Extensions/StringExtensions.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace RestSharp.Authenticators.OAuth.Extensions
+{
+    internal static class StringExtensions
+    {
+        public static bool IsNullOrBlank(this string value)
+        {
+            return String.IsNullOrEmpty(value) ||
+                (!String.IsNullOrEmpty(value) && value.Trim() == String.Empty);
+        }
+
+        public static bool EqualsIgnoreCase(this string left, string right)
+        {
+            return String.Compare(left, right, StringComparison.OrdinalIgnoreCase) == 0;
+        }
+
+        public static bool EqualsAny(this string input, params string[] args)
+        {
+            return args.Aggregate(false, (current, arg) => current | input.Equals(arg));
+        }
+
+        public static string FormatWith(this string format, params object[] args)
+        {
+            return String.Format(format, args);
+        }
+
+        public static string FormatWithInvariantCulture(this string format, params object[] args)
+        {
+            return String.Format(CultureInfo.InvariantCulture, format, args);
+        }
+
+        public static string Then(this string input, string value)
+        {
+            return String.Concat(input, value);
+        }
+
+        public static string UrlEncode(this string value)
+        {
+            // [DC] This is more correct than HttpUtility; it escapes spaces as %20, not +
+            return Uri.EscapeDataString(value);
+        }
+
+        public static string UrlDecode(this string value)
+        {
+            return Uri.UnescapeDataString(value);
+        }
+
+        public static Uri AsUri(this string value)
+        {
+            return new Uri(value);
+        }
+
+        public static string ToBase64String(this byte[] input)
+        {
+            return Convert.ToBase64String(input);
+        }
+
+        public static byte[] GetBytes(this string input)
+        {
+            return Encoding.UTF8.GetBytes(input);
+        }
+
+        public static string PercentEncode(this string s)
+        {
+            var bytes = s.GetBytes();
+            var sb = new StringBuilder();
+            foreach (var b in bytes)
+            {
+                // [DC]: Support proper encoding of special characters (\n\r\t\b)
+                if ((b > 7 && b < 11) || b == 13)
+                {
+                    sb.Append(string.Format("%0{0:X}", b));
+                }
+                else
+                {
+                    sb.Append(string.Format("%{0:X}", b));
+                }
+            }
+            return sb.ToString();
+        }
+
+        public static IDictionary<string, string> ParseQueryString(this string query)
+        {
+            // [DC]: This method does not URL decode, and cannot handle decoded input
+            if (query.StartsWith("?")) query = query.Substring(1);
+
+            if (query.Equals(string.Empty))
+            {
+                return new Dictionary<string, string>();
+            }
+
+            var parts = query.Split(new[] { '&' });
+
+            return parts.Select(
+                part => part.Split(new[] { '=' })).ToDictionary(
+                    pair => pair[0], pair => pair[1]
+                );
+        }
+
+        private const RegexOptions Options = RegexOptions.IgnoreCase;
+    }
+}

RestSharp.WinRT/Authenticators/OAuth/Extensions/TimeExtensions.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace RestSharp.Authenticators.OAuth.Extensions
+{
+    internal static class TimeExtensions
+    {
+        public static DateTime FromNow(this TimeSpan value)
+        {
+            return new DateTime((DateTime.Now + value).Ticks);
+        }
+
+        public static DateTime FromUnixTime(this long seconds)
+        {
+            var time = new DateTime(1970, 1, 1);
+            time = time.AddSeconds(seconds);
+
+            return time.ToLocalTime();
+        }
+
+        public static long ToUnixTime(this DateTime dateTime)
+        {
+            var timeSpan = (dateTime - new DateTime(1970, 1, 1));
+            var timestamp = (long)timeSpan.TotalSeconds;
+
+            return timestamp;
+        }
+    }
+}

RestSharp.WinRT/Authenticators/OAuth/HttpPostParameter.cs

@@ -0,0 +1,43 @@
+using System.IO;
+
+namespace RestSharp.Authenticators.OAuth
+{
+    internal class HttpPostParameter : WebParameter
+    {
+        public HttpPostParameter(string name, string value)
+            : base(name, value)
+        {
+        }
+
+        public virtual HttpPostParameterType Type { get; private set; }
+        public virtual string FileName { get; private set; }
+        public virtual string FilePath { get; private set; }
+        public virtual Stream FileStream { get; set; }
+        public virtual string ContentType { get; private set; }
+
+        public static HttpPostParameter CreateFile(string name, string fileName, string filePath, string contentType)
+        {
+            var parameter = new HttpPostParameter(name, string.Empty)
+            {
+                Type = HttpPostParameterType.File,
+                FileName = fileName,
+                FilePath = filePath,
+                ContentType = contentType,
+            };
+            return parameter;
+        }
+
+        public static HttpPostParameter CreateFile(string name, string fileName, Stream fileStream, string contentType)
+        {
+            var parameter = new HttpPostParameter(name, string.Empty)
+            {
+                Type = HttpPostParameterType.File,
+                FileName = fileName,
+                FileStream = fileStream,
+                ContentType = contentType,
+            };
+
+            return parameter;
+        }
+    }
+}

RestSharp.WinRT/Authenticators/OAuth/HttpPostParameterType.cs

@@ -0,0 +1,8 @@
+namespace RestSharp.Authenticators.OAuth
+{
+    internal enum HttpPostParameterType
+    {
+        Field,
+        File
+    }
+}

RestSharp.WinRT/Authenticators/OAuth/OAuthParameterHandling.cs

@@ -0,0 +1,8 @@
+namespace RestSharp.Authenticators.OAuth
+{
+    public enum OAuthParameterHandling
+    {
+        HttpAuthorizationHeader,
+        UrlOrPostParameters
+    }
+}

RestSharp.WinRT/Authenticators/OAuth/OAuthSignatureMethod.cs

@@ -0,0 +1,9 @@
+namespace RestSharp.Authenticators.OAuth
+{
+    public enum OAuthSignatureMethod
+    {
+        HmacSha1,
+        PlainText,
+        RsaSha1
+    }
+}

RestSharp.WinRT/Authenticators/OAuth/OAuthSignatureTreatment.cs

@@ -0,0 +1,8 @@
+namespace RestSharp.Authenticators.OAuth
+{
+    public enum OAuthSignatureTreatment
+    {
+        Escaped,
+        Unescaped
+    }
+}