How to retrieve a Report record via the Haiku LMS API, using C#.

gistfile1.cs

// Based on code from the following sources:
// * http://www.voiceoftech.com/swhitley/index.php/2009/03/twitter-oauth-with-net/
// * http://oauth.googlecode.com/svn/code/csharp/
// Note: if you're using mono the following command will compile this code `gmcs -r:System.Web.dll this_file.cs`

using System;
using System.Security.Cryptography;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Web;
using System.IO;
using System.Collections.Specialized;

// Program start class
class ExampleClass
{
	public static void Main()
	{
		string uri = "https://my-domain.haikulearning.com/do/services/report/1";
		string query = "";
		OAuthBase.Method method = OAuthBase.Method.GET;

		OAuthBase oAuth = new OAuthBase();
		oAuth.ConsumerKey = "api_key_EUNzNgVkrpFUFg";
		oAuth.ConsumerSecret = "api_secret_KBq6hTvjjvqAWOPz6c4WnQHN6jvkU8";
		oAuth.Token = "token_959b3659b65ddbb6f8552c3401";
		oAuth.TokenSecret = "secret_40ec1d3617e7f58811c2f1e4416dcf2f7";

		System.Console.WriteLine("Sending a "+ method.ToString() +" request to:");
		System.Console.WriteLine(uri);

		if (query.Length > 0 && (method == OAuthBase.Method.POST || method == OAuthBase.Method.DELETE))
		{
			System.Console.WriteLine("With the following data:");
			System.Console.WriteLine(query);
		}

		System.Console.WriteLine("XML response:");
		string xml = oAuth.oAuthWebRequest(method, uri, query);
		System.Console.WriteLine(xml);
		//<?xml version="1.0" encoding="UTF-8"?>
		//<response status="ok">
		//<reports page="1" records_per_page="50" total_record_count="1" page_count="1">
		//	<report id="1" report_type="Grades" name="This Year's Grades" created_at="2010-09-20 19:04:42" last_viewed_at="2010-09-25 19:04:42">
		//		<csv status="Ready" generated_at="2010-09-28 01:29:51" url="https://my-domain.myhaikuclass.com/example/report_export.csv" />
		//	</report>
		//</reports>
		//</response>
	}
}

public class OAuthBase
{
	/// <summary>
	/// Provides a predefined set of algorithms that are supported officially by the protocol
	/// </summary>
	public enum SignatureTypes
	{
		HMACSHA1,
		PLAINTEXT,
		RSASHA1
	}

	/// <summary>
	/// Provides an internal structure to sort the query parameter
	/// </summary>
	protected class QueryParameter
	{
		private string name = null;
		private string value = null;

		public QueryParameter(string name, string value)
		{
			this.name = name;
			this.value = value;
		}

		public string Name
		{
			get { return name; }
		}

		public string Value
		{
			get { return value; }
		}
	}

	/// <summary>
	/// Comparer class used to perform the sorting of the query parameters
	/// </summary>
	protected class QueryParameterComparer : IComparer<QueryParameter>
	{

		#region IComparer<QueryParameter> Members

		public int Compare(QueryParameter x, QueryParameter y)
		{
			if (x.Name == y.Name)
			{
				return string.Compare(x.Value, y.Value);
			}
			else
			{
				return string.Compare(x.Name, y.Name);
			}
		}

		#endregion
	}

	protected const string OAuthVersion = "1.0";
	protected const string OAuthParameterPrefix = "oauth_";

	//
	// List of know and used oauth parameters' names
	//		
	protected const string OAuthConsumerKeyKey = "oauth_consumer_key";
	protected const string OAuthCallbackKey = "oauth_callback";
	protected const string OAuthVersionKey = "oauth_version";
	protected const string OAuthSignatureMethodKey = "oauth_signature_method";
	protected const string OAuthSignatureKey = "oauth_signature";
	protected const string OAuthTimestampKey = "oauth_timestamp";
	protected const string OAuthNonceKey = "oauth_nonce";
	protected const string OAuthTokenKey = "oauth_token";
	protected const string OAuthTokenSecretKey = "oauth_token_secret";
	protected const string OAuthVerifierKey = "oauth_verifier";

	protected const string HMACSHA1SignatureType = "HMAC-SHA1";
	protected const string PlainTextSignatureType = "PLAINTEXT";
	protected const string RSASHA1SignatureType = "RSA-SHA1";

	protected Random random = new Random();

	protected string unreservedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.~";

	/// <summary>
	/// Helper function to compute a hash value
	/// </summary>
	/// <param name="hashAlgorithm">The hashing algoirhtm used. If that algorithm needs some initialization, like HMAC and its derivatives, they should be initialized prior to passing it to this function</param>
	/// <param name="data">The data to hash</param>
	/// <returns>a Base64 string of the hash value</returns>
	private string ComputeHash(HashAlgorithm hashAlgorithm, string data)
	{
		if (hashAlgorithm == null)
		{
			throw new ArgumentNullException("hashAlgorithm");
		}

		if (string.IsNullOrEmpty(data))
		{
			throw new ArgumentNullException("data");
		}

		byte[] dataBuffer = System.Text.Encoding.ASCII.GetBytes(data);
		byte[] hashBytes = hashAlgorithm.ComputeHash(dataBuffer);

		return Convert.ToBase64String(hashBytes);
	}

	/// <summary>
	/// Internal function to cut out all non oauth query string parameters (all parameters not begining with "oauth_")
	/// </summary>
	/// <param name="parameters">The query string part of the Url</param>
	/// <returns>A list of QueryParameter each containing the parameter name and value</returns>
	private List<QueryParameter> GetQueryParameters(string parameters)
	{
		if (parameters.StartsWith("?"))
		{
			parameters = parameters.Remove(0, 1);
		}

		List<QueryParameter> result = new List<QueryParameter>();

		if (!string.IsNullOrEmpty(parameters))
		{
			string[] p = parameters.Split('&');
			foreach (string s in p)
			{
				if (!string.IsNullOrEmpty(s) && !s.StartsWith(OAuthParameterPrefix))
				{
					if (s.IndexOf('=') > -1)
					{
						string[] temp = s.Split('=');
						result.Add(new QueryParameter(temp[0], temp[1]));
					}
					else
					{
						result.Add(new QueryParameter(s, string.Empty));
					}
				}
			}
		}

		return result;
	}

	/// <summary>
	/// This is a different Url Encode implementation since the default .NET one outputs the percent encoding in lower case.
	/// While this is not a problem with the percent encoding spec, it is used in upper case throughout OAuth
	/// </summary>
	/// <param name="value">The value to Url encode</param>
	/// <returns>Returns a Url encoded string</returns>
	public string UrlEncode(string value)
	{
		StringBuilder result = new StringBuilder();

		foreach (char symbol in value)
		{
			if (unreservedChars.IndexOf(symbol) != -1)
			{
				result.Append(symbol);
			}
			else
			{
				result.Append('%' + String.Format("{0:X2}", (int)symbol));
			}
		}

		return result.ToString();
	}

	/// <summary>
	/// Normalizes the request parameters according to the spec
	/// </summary>
	/// <param name="parameters">The list of parameters already sorted</param>
	/// <returns>a string representing the normalized parameters</returns>
	protected string NormalizeRequestParameters(IList<QueryParameter> parameters)
	{
		StringBuilder sb = new StringBuilder();
		QueryParameter p = null;
		for (int i = 0; i < parameters.Count; i++)
		{
			p = parameters[i];
			sb.AppendFormat("{0}={1}", p.Name, p.Value);

			if (i < parameters.Count - 1)
			{
				sb.Append("&");
			}
		}

		return sb.ToString();
	}

	/// <summary>
	/// Generate the signature base that is used to produce the signature
	/// </summary>
	/// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
	/// <param name="callBackUrl">The callback URL (for OAuth 1.0a).If your client cannot accept callbacks, the value MUST be 'oob' </param>
	/// <param name="oauthVerifier">This value MUST be included when exchanging Request Tokens for Access Tokens. Otherwise pass a null or an empty string</param>
	/// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
	/// <param name="signatureType">The signature type. To use the default values use <see cref="OAuthBase.SignatureTypes">OAuthBase.SignatureTypes</see>.</param>
	/// <returns>The signature base</returns>
	public string GenerateSignatureBase(Uri url, string callBackUrl, string oauthVerifier, string httpMethod, string timeStamp, string nonce, string signatureType, out string normalizedUrl, out string normalizedRequestParameters)
	{
		if (this.Token == null)
		{
			this.Token = string.Empty;
		}

		if (this.TokenSecret == null)
		{
			this.TokenSecret = string.Empty;
		}

		if (string.IsNullOrEmpty(this.ConsumerKey))
		{
			throw new ArgumentNullException("consumerKey");
		}

		if (string.IsNullOrEmpty(httpMethod))
		{
			throw new ArgumentNullException("httpMethod");
		}

		if (string.IsNullOrEmpty(signatureType))
		{
			throw new ArgumentNullException("signatureType");
		}

		normalizedUrl = null;
		normalizedRequestParameters = null;

		List<QueryParameter> parameters = GetQueryParameters(url.Query);
		parameters.Add(new QueryParameter(OAuthVersionKey, OAuthVersion));
		parameters.Add(new QueryParameter(OAuthNonceKey, nonce));
		parameters.Add(new QueryParameter(OAuthTimestampKey, timeStamp));
		parameters.Add(new QueryParameter(OAuthSignatureMethodKey, signatureType));
		parameters.Add(new QueryParameter(OAuthConsumerKeyKey, this.ConsumerKey));

		if (!string.IsNullOrEmpty(callBackUrl))
		{
			parameters.Add(new QueryParameter(OAuthCallbackKey, UrlEncode(callBackUrl)));
		}


		if (!string.IsNullOrEmpty(oauthVerifier))
		{
			parameters.Add(new QueryParameter(OAuthVerifierKey, oauthVerifier));
		}

		if (!string.IsNullOrEmpty(this.Token))
		{
			parameters.Add(new QueryParameter(OAuthTokenKey, this.Token));
		}

		parameters.Sort(new QueryParameterComparer());

		normalizedUrl = string.Format("{0}://{1}", url.Scheme, url.Host);
		if (!((url.Scheme == "http" && url.Port == 80) || (url.Scheme == "https" && url.Port == 443)))
		{
			normalizedUrl += ":" + url.Port;
		}
		normalizedUrl += url.AbsolutePath;
		normalizedRequestParameters = NormalizeRequestParameters(parameters);

		StringBuilder signatureBase = new StringBuilder();
		signatureBase.AppendFormat("{0}&", httpMethod.ToUpper());
		signatureBase.AppendFormat("{0}&", UrlEncode(normalizedUrl));
		signatureBase.AppendFormat("{0}", UrlEncode(normalizedRequestParameters));

		return signatureBase.ToString();
	}

	/// <summary>
	/// Generate the signature value based on the given signature base and hash algorithm
	/// </summary>
	/// <param name="signatureBase">The signature based as produced by the GenerateSignatureBase method or by any other means</param>
	/// <param name="hash">The hash algorithm used to perform the hashing. If the hashing algorithm requires initialization or a key it should be set prior to calling this method</param>
	/// <returns>A base64 string of the hash value</returns>
	public string GenerateSignatureUsingHash(string signatureBase, HashAlgorithm hash)
	{
		return ComputeHash(hash, signatureBase);
	}

	/// <summary>
	/// Generates a signature using the HMAC-SHA1 algorithm
	/// </summary>	
	/// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
	/// <param name="callBackUrl">The callback URL (for OAuth 1.0a).If your client cannot accept callbacks, the value MUST be 'oob' </param>
	/// <param name="oauthVerifier">This value MUST be included when exchanging Request Tokens for Access Tokens. Otherwise pass a null or an empty string</param>
	/// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
	/// <returns>A base64 string of the hash value</returns>
	public string GenerateSignature(Uri url, string callBackUrl, string oauthVerifier, string httpMethod, string timeStamp, string nonce, out string normalizedUrl, out string normalizedRequestParameters)
	{
		return GenerateSignature(url, callBackUrl, oauthVerifier, httpMethod, timeStamp, nonce, SignatureTypes.HMACSHA1, out normalizedUrl, out normalizedRequestParameters);
	}

	/// <summary>
	/// Generates a signature using the specified signatureType 
	/// </summary>	
	/// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
	/// <param name="callBackUrl">The callback URL (for OAuth 1.0a).If your client cannot accept callbacks, the value MUST be 'oob' </param>
	/// <param name="oauthVerifier">This value MUST be included when exchanging Request Tokens for Access Tokens. Otherwise pass a null or an empty string</param>
	/// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
	/// <param name="signatureType">The type of signature to use</param>
	/// <returns>A base64 string of the hash value</returns>
	public string GenerateSignature(Uri url, string callBackUrl, string oauthVerifier, string httpMethod, string timeStamp, string nonce, SignatureTypes signatureType, out string normalizedUrl, out string normalizedRequestParameters)
	{
		normalizedUrl = null;
		normalizedRequestParameters = null;

		switch (signatureType)
		{
			case SignatureTypes.PLAINTEXT:
				return HttpUtility.UrlEncode(string.Format("{0}&{1}", this.ConsumerSecret, this.TokenSecret));
			case SignatureTypes.HMACSHA1:
				string signatureBase = GenerateSignatureBase(url, callBackUrl, oauthVerifier, httpMethod, timeStamp, nonce, HMACSHA1SignatureType, out normalizedUrl, out normalizedRequestParameters);

				HMACSHA1 hmacsha1 = new HMACSHA1();
				hmacsha1.Key = Encoding.ASCII.GetBytes(string.Format("{0}&{1}", UrlEncode(this.ConsumerSecret), string.IsNullOrEmpty(this.TokenSecret) ? "" : UrlEncode(this.TokenSecret)));

				return GenerateSignatureUsingHash(signatureBase, hmacsha1);
			case SignatureTypes.RSASHA1:
				throw new NotImplementedException();
			default:
				throw new ArgumentException("Unknown signature type", "signatureType");
		}
	}

	/// <summary>
	/// Generate the timestamp for the signature		
	/// </summary>
	/// <returns></returns>
	public virtual string GenerateTimeStamp()
	{
		// Default implementation of UNIX time of the current UTC time
		TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
		return Convert.ToInt64(ts.TotalSeconds).ToString();
	}

	/// <summary>
	/// Generate a nonce
	/// </summary>
	/// <returns></returns>
	public virtual string GenerateNonce()
	{
		// Just a simple implementation of a random number between 123400 and 9999999
		return random.Next(123400, 9999999).ToString();
	}

	public enum Method { GET, POST, PUT, DELETE };
	private string _consumerKey = "asdf";
	private string _consumerSecret = "ghjk";
	private string _token = "";
	private string _tokenSecret = "";
	private string _callBackUrl = "oob";
	private string _oauthVerifier = "";

	public string ConsumerKey { get { return _consumerKey;} set { _consumerKey = value; } }
	public string ConsumerSecret { get { return _consumerSecret;} set { _consumerSecret = value; } }
	public string Token { get { return _token; } set { _token = value; } }
	public string TokenSecret { get { return _tokenSecret; } set { _tokenSecret = value; } }
	public string CallBackUrl { get { return _callBackUrl; } set { _callBackUrl = value; } }
	public string OAuthVerifier { get { return _oauthVerifier; } set { _oauthVerifier = value; } }


	/// <summary>
	/// Submit a web request using oAuth.
	/// </summary>
	/// <param name="method">GET or POST</param>
	/// <param name="url">The full url, including the querystring.</param>
	/// <param name="postData">Data to post (querystring format)</param>
	/// <returns>The web server response.</returns>
	public string oAuthWebRequest(Method method, string url, string postData)
	{
		string outUrl = "";
		string querystring = "";
		string ret = "";


		//Setup postData for signing.
		//Add the postData to the querystring.
		if (method == Method.POST || method == Method.DELETE)
		{
			if (postData.Length > 0)
			{
				//Decode the parameters and re-encode using the oAuth UrlEncode method.
				NameValueCollection qs = HttpUtility.ParseQueryString(postData);
				postData = "";
				foreach (string key in qs.AllKeys)
				{
					if (postData.Length > 0)
					{
						postData += "&";
					}
					qs[key] = HttpUtility.UrlDecode(qs[key]);
					qs[key] = this.UrlEncode(qs[key]);
					postData += key + "=" + qs[key];

				}
				if (url.IndexOf("?") > 0)
				{
					url += "&";
				}
				else
				{
					url += "?";
				}
				url += postData;
			}
		}

		Uri uri = new Uri(url);
		
		string nonce = this.GenerateNonce();
		string timeStamp = this.GenerateTimeStamp();

		//Generate Signature
		string sig = this.GenerateSignature(uri,
			this.CallBackUrl,
			this.OAuthVerifier,
			method.ToString(),
			timeStamp,
			nonce,
			out outUrl,
			out querystring);

		querystring += "&oauth_signature=" + this.UrlEncode(sig);

		//Convert the querystring to postData
		if (method == Method.POST || method == Method.DELETE)
		{
			postData = querystring;
			querystring = "";
		}

		if (querystring.Length > 0)
		{
			outUrl += "?";
		}

		ret = WebRequest(method, outUrl +	querystring, postData);

		return ret;
	}
	
	/// <summary>
	/// Web Request Wrapper
	/// </summary>
	/// <param name="method">Http Method</param>
	/// <param name="url">Full url to the web resource</param>
	/// <param name="postData">Data to post in querystring format</param>
	/// <returns>The web server response.</returns>
	public string WebRequest(Method method, string url, string postData)
	{
		HttpWebRequest webRequest = null;
		StreamWriter requestWriter = null;
		string responseData = "";

		webRequest = System.Net.WebRequest.Create(url) as HttpWebRequest;
		webRequest.Method = method.ToString();
		webRequest.ServicePoint.Expect100Continue = false;
		//webRequest.UserAgent	= "Identify your application please.";
		//webRequest.Timeout = 20000;

		if (method == Method.POST || method == Method.DELETE)
		{
			webRequest.ContentType = "application/x-www-form-urlencoded";

			//POST the data.
			requestWriter = new StreamWriter(webRequest.GetRequestStream());
			try
			{
				requestWriter.Write(postData);
			}
			catch
			{
				throw;
			}
			finally
			{
				requestWriter.Close();
				requestWriter = null;
			}
		}

		responseData = WebResponseGet(webRequest);

		webRequest = null;

		return responseData;

	}
	
	/// <summary>
	/// Process the web response.
	/// </summary>
	/// <param name="webRequest">The request object.</param>
	/// <returns>The response data.</returns>
	public string WebResponseGet(HttpWebRequest webRequest)
	{
		StreamReader responseReader = null;
		string responseData = "";

		try
		{
			responseReader = new StreamReader(webRequest.GetResponse().GetResponseStream());
			responseData = responseReader.ReadToEnd();
		}
		catch
		{
			throw;
		}
		finally
		{
			webRequest.GetResponse().GetResponseStream().Close();
			responseReader.Close();
			responseReader = null;
		}

		return responseData;
	}
}