Posts Tagged ‘yahoo’

Step 1 :  Register your application to get consumer key and consumer secret

Here

Don’t forgot to change prermision to read Contacts

Step 2:  In App_Code Folder Make One New Class . . And Write The Following Code In That Class

________________________________________________________________________________________________

using System;
using System.Security.Cryptography;
using System.Collections.Generic;
using System.Text;
using System.Web;

namespace OAuth
{
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 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>
protected 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=”consumerKey”>The consumer key</param>
/// <param name=”token”>The token, if available. If not available pass null or an empty string</param>
/// <param name=”tokenSecret”>The token secret, if available. If not available pass 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 consumerKey, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, string signatureType, out string normalizedUrl, out string normalizedRequestParameters)
{
if (token == null)
{
token = string.Empty;
}

if (tokenSecret == null)
{
tokenSecret = string.Empty;
}

if (string.IsNullOrEmpty(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, consumerKey));

if (!string.IsNullOrEmpty(token))
{
parameters.Add(new QueryParameter(OAuthTokenKey, 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=”consumerKey”>The consumer key</param>
/// <param name=”consumerSecret”>The consumer seceret</param>
/// <param name=”token”>The token, if available. If not available pass null or an empty string</param>
/// <param name=”tokenSecret”>The token secret, if available. If not available pass 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 consumerKey, string consumerSecret, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, out string normalizedUrl, out string normalizedRequestParameters)
{
return GenerateSignature(url, consumerKey, consumerSecret, token, tokenSecret, 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=”consumerKey”>The consumer key</param>
/// <param name=”consumerSecret”>The consumer seceret</param>
/// <param name=”token”>The token, if available. If not available pass null or an empty string</param>
/// <param name=”tokenSecret”>The token secret, if available. If not available pass 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 consumerKey, string consumerSecret, string token, string tokenSecret, 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}”, consumerSecret, tokenSecret));
case SignatureTypes.HMACSHA1:
string signatureBase = GenerateSignatureBase(url, consumerKey, token, tokenSecret, httpMethod, timeStamp, nonce, HMACSHA1SignatureType, out normalizedUrl, out normalizedRequestParameters);

HMACSHA1 hmacsha1 = new HMACSHA1();
hmacsha1.Key = Encoding.ASCII.GetBytes(string.Format(“{0}&{1}”, UrlEncode(consumerSecret), string.IsNullOrEmpty(tokenSecret) ? “” : UrlEncode(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);
string timeStamp = ts.TotalSeconds.ToString();
timeStamp = timeStamp.Substring(0, timeStamp.IndexOf(“.”));
return timeStamp;
}
/// <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();
}

}
}

_____________________________________________________________________________________________

Step 3: Now Make 1 .aspx Page ,, Say Yahoo.aspx
Step 4 :Now In yahoo.aspx Page Write this simple code

<asp:Button ID=”Button1″ runat=”server” Text=”Connect to Yahoo!” OnClick=”Button1_Click” />
<asp:GridView ID=”grvMyFriends” runat=”server” AutoGenerateColumns=”true”>

</asp:GridView>

Step 5: Now In Yahoo.aspx.cs File Write This Code :

______________________________________________________________________________________________

public string ConsumerKey
{
get
{
return “YourConsumerKey”;
}
}
public string ConsumerSecret
{
get
{
return “YourConsumerSecret”;
}
}
public string OauthVerifier
{
get
{
try
{
if (!string.IsNullOrEmpty(Session[“Oauth_Verifier”].ToString()))
return Session[“Oauth_Verifier”].ToString();
else
return string.Empty;
}
catch
{
return string.Empty;
}
}
set
{
Session[“Oauth_Verifier”] = value;
}
}
public string OauthToken
{
get
{
if (!string.IsNullOrEmpty(Session[“Oauth_Token”].ToString()))
return Session[“Oauth_Token”].ToString();
else
return string.Empty;
}
set
{
Session[“Oauth_Token”] = value;
}
}
public string OauthTokenSecret
{
get
{
if (!string.IsNullOrEmpty(Session[“Oauth_Token_Secret”].ToString()))
return Session[“Oauth_Token_Secret”].ToString();
else
return string.Empty;
}
set
{
Session[“Oauth_Token_Secret”] = value;
}
}
public string OauthSessionHandle
{
get
{
if (!string.IsNullOrEmpty(Session[“Oauth_Session_Handle”].ToString()))
return Session[“Oauth_Session_Handle”].ToString();
else
return string.Empty;
}
set
{
Session[“Oauth_Session_Handle”] = value;
}
}
public string OauthYahooGuid
{
get
{
try
{
if (!string.IsNullOrEmpty(Session[“Oauth_Yahoo_Guid”].ToString()))
return Session[“Oauth_Yahoo_Guid”].ToString();
else
return string.Empty;
}
catch
{
return string.Empty;
}
}
set
{
Session[“Oauth_Yahoo_Guid”] = value;
}
}

protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
string oauth_token = Request[“oauth_token”];
string oauth_verifier = Request[“oauth_verifier”];

if (!string.IsNullOrEmpty(oauth_verifier) && oauth_verifier != “”)
{
Button1.Visible = false;
OauthToken = oauth_token;
OauthVerifier = oauth_verifier;
Page.ClientScript.RegisterStartupScript(typeof(ScriptManager),”refresh”, “// “);

}
else if (!string.IsNullOrEmpty(OauthVerifier))
{
Button1.Visible = false;
if (string.IsNullOrEmpty(OauthYahooGuid))
GetAccessToken(OauthToken, OauthVerifier);
RetriveContacts();
}
}

}
private string GetRequestToken()
{
string authorizationUrl = string.Empty;
OAuthBase oauth = new OAuthBase();

Uri uri = new Uri(“https://api.login.yahoo.com/oauth/v2/get_request_token&#8221;);
string nonce = oauth.GenerateNonce();
string timeStamp = oauth.GenerateTimeStamp();
string normalizedUrl;
string normalizedRequestParameters;
string sig = oauth.GenerateSignature(uri, ConsumerKey, ConsumerSecret, string.Empty, string.Empty, “GET”, timeStamp, nonce, OAuthBase.SignatureTypes.PLAINTEXT, out normalizedUrl, out normalizedRequestParameters); //OAuthBase.SignatureTypes.HMACSHA1
StringBuilder sbRequestToken = new StringBuilder(uri.ToString());
sbRequestToken.AppendFormat(“?oauth_nonce={0}&”, nonce);
sbRequestToken.AppendFormat(“oauth_timestamp={0}&”, timeStamp);
sbRequestToken.AppendFormat(“oauth_consumer_key={0}&”, ConsumerKey);
sbRequestToken.AppendFormat(“oauth_signature_method={0}&”, “PLAINTEXT”); //HMAC-SHA1
sbRequestToken.AppendFormat(“oauth_signature={0}&”, sig);
sbRequestToken.AppendFormat(“oauth_version={0}&”, “1.0”);
sbRequestToken.AppendFormat(“oauth_callback={0}”, HttpUtility.UrlEncode(“YourRedirectUrl”));
try
{
string returnStr = string.Empty;
string[] returnData;

HttpWebRequest req = (HttpWebRequest)WebRequest.Create(sbRequestToken.ToString());
HttpWebResponse res = (HttpWebResponse)req.GetResponse();
StreamReader streamReader = new StreamReader(res.GetResponseStream());
returnStr = streamReader.ReadToEnd();
returnData = returnStr.Split(new Char[] { ‘&’ });
//Response.Write(returnStr);

int index;
if (returnData.Length > 0)
{
//index = returnData[0].IndexOf(“=”);
//string oauth_token = returnData[0].Substring(index + 1);
//Session[“Oauth_Token”] = oauth_token;

index = returnData[1].IndexOf(“=”);
string oauth_token_secret = returnData[1].Substring(index + 1);
OauthTokenSecret = oauth_token_secret;

//index = returnData[2].IndexOf(“=”);
//int oauth_expires_in;
//Int32.TryParse(returnData[2].Substring(index + 1), out oauth_expires_in);
//Session[“Oauth_Expires_In”] = oauth_expires_in;

index = returnData[3].IndexOf(“=”);
string oauth_request_auth_url = returnData[3].Substring(index + 1);
authorizationUrl = HttpUtility.UrlDecode(oauth_request_auth_url);
}
}
catch (WebException ex)
{
Response.Write(ex.Message);
}
return authorizationUrl;
}
private void RedirectUserForAuthorization(string authorizationUrl)
{
Page.ClientScript.RegisterStartupScript(typeof(ScriptManager),”openwin”, “// “);
}
private void GetAccessToken(string oauth_token, string oauth_verifier)
{
OAuthBase oauth = new OAuthBase();

Uri uri = new Uri(“https://api.login.yahoo.com/oauth/v2/get_token&#8221;);
string nonce = oauth.GenerateNonce();
string timeStamp = oauth.GenerateTimeStamp();
string sig = ConsumerSecret + “%26” + OauthTokenSecret;

StringBuilder sbAccessToken = new StringBuilder(uri.ToString());
sbAccessToken.AppendFormat(“?oauth_consumer_key={0}&”, ConsumerKey);
sbAccessToken.AppendFormat(“oauth_signature_method={0}&”, “PLAINTEXT”); //HMAC-SHA1
sbAccessToken.AppendFormat(“oauth_signature={0}&”, sig);
sbAccessToken.AppendFormat(“oauth_timestamp={0}&”, timeStamp);
sbAccessToken.AppendFormat(“oauth_version={0}&”, “1.0”);
sbAccessToken.AppendFormat(“oauth_token={0}&”, oauth_token);
sbAccessToken.AppendFormat(“oauth_nonce={0}&”, nonce);
sbAccessToken.AppendFormat(“oauth_verifier={0}”, oauth_verifier);
try
{
string returnStr = string.Empty;
string[] returnData;

HttpWebRequest req = (HttpWebRequest)WebRequest.Create(sbAccessToken.ToString());
HttpWebResponse res = (HttpWebResponse)req.GetResponse();
StreamReader streamReader = new StreamReader(res.GetResponseStream());
returnStr = streamReader.ReadToEnd();
returnData = returnStr.Split(new Char[] { ‘&’ });
int index;
if (returnData.Length > 0)
{
index = returnData[0].IndexOf(“=”);
OauthToken = returnData[0].Substring(index + 1);

index = returnData[1].IndexOf(“=”);
string oauth_token_secret = returnData[1].Substring(index + 1);
OauthTokenSecret = oauth_token_secret;
index = returnData[3].IndexOf(“=”);
string oauth_session_handle = returnData[3].Substring(index + 1);
OauthSessionHandle = oauth_session_handle;
index = returnData[5].IndexOf(“=”);
string xoauth_yahoo_guid = returnData[5].Substring(index + 1);
OauthYahooGuid = xoauth_yahoo_guid;
}
}
catch (WebException ex)
{
Response.Write(ex.Message);
}
}

private void RetriveContacts()
{
OAuthBase oauth = new OAuthBase();

Uri uri = new Uri(“http://social.yahooapis.com/v1/user/&#8221; + OauthYahooGuid + “/contacts?format=XML”);
string nonce = oauth.GenerateNonce();
string timeStamp = oauth.GenerateTimeStamp();
string normalizedUrl;
string normalizedRequestParameters;
string sig = oauth.GenerateSignature(uri, ConsumerKey, ConsumerSecret, OauthToken, OauthTokenSecret, “GET”, timeStamp, nonce, OAuthBase.SignatureTypes.HMACSHA1, out normalizedUrl, out normalizedRequestParameters);

StringBuilder sbGetContacts = new StringBuilder(uri.ToString());
try
{
string returnStr = string.Empty;
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(sbGetContacts.ToString());
req.Method = “GET”;
string authHeader = “Authorization: OAuth ” +
“realm=\”yahooapis.com\”” +
“,oauth_consumer_key=\”” + ConsumerKey + “\”” +
“,oauth_nonce=\”” + nonce + “\”” +
“,oauth_signature_method=\”HMAC-SHA1\”” +
“,oauth_timestamp=\”” + timeStamp + “\”” +
“,oauth_token=\”” + OauthToken + “\”” +
“,oauth_version=\”1.0\”” +
“,oauth_signature=\”” + HttpUtility.UrlEncode(sig) + “\””;
req.Headers.Add(authHeader);

HttpWebResponse res = (HttpWebResponse)req.GetResponse();
StreamReader streamReader = new StreamReader(res.GetResponseStream());
returnStr = streamReader.ReadToEnd();
XmlDocument xmldoc = new XmlDocument();
xmldoc.LoadXml(returnStr);
XmlNodeList elemList = xmldoc.DocumentElement.GetElementsByTagName(“fields”);

ArrayList emails = new ArrayList();
for (int i = 0; i < elemList.Count; i++)
{
if (elemList[i].ChildNodes[1].InnerText == “email”)
emails.Add(elemList[i].ChildNodes[2].InnerText);
}
grvMyFriends.DataSource = emails;
grvMyFriends.DataBind();
}

catch (Exception ex)
{
}
}
protected void Button1_Click(object sender, EventArgs e)
{
string authorizationUrl = string.Empty;
authorizationUrl = GetRequestToken();
RedirectUserForAuthorization(authorizationUrl);
}

______________________________________________________________________________________________

Hope This Post Will Help you Somehow 🙂 . . . Feel Free To Ask Anything You Need.

Waiting For Your Valuable Feedback.