Get Yahoo Contact for C#
Create new Website
Create AppCode Folder
Create OAuthBase.cs in AppCode Folder
like
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();
}
}
}
Download OAuth.Net.Common.dll and reference
to bin folder
Create oauth-test.aspx page like
<%@ Page
Language="C#"
AutoEventWireup="true"
CodeFile="oauth-test.aspx.cs"
Inherits="test_oauth_test"
%>
<!DOCTYPE html PUBLIC
"-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title>Untitled
Page</title>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:Button ID="Button1" runat="server" Text="Connect to Yahoo!" OnClick="Button1_Click"
/>
<asp:Label runat="server" ID="ResponseMessage1"></asp:Label>
<asp:GridView ID="grvMyFriends" runat="server" AutoGenerateColumns="false" CellPadding="5"
GridLines="None">
<HeaderStyle BackColor="#025A8E" Font-Bold="true" ForeColor="White" HorizontalAlign="Left" />
<RowStyle BackColor="#DFDFDF" HorizontalAlign="Left" />
<AlternatingRowStyle BackColor="#F0F0F0" HorizontalAlign="Left" />
<Columns>
<asp:TemplateField HeaderText="Email">
<ItemTemplate>
<%#
Container.DataItem %>
</ItemTemplate>
</asp:TemplateField>
</Columns>
<EmptyDataTemplate>
No Friend List Found
</EmptyDataTemplate>
</asp:GridView>
</div>
</form>
</body>
</html>
Create oauth-test.aspx.cs file like
using System;
using
System.Configuration;
using
System.Data;
using
System.Web;
using
System.Web.Security;
using
System.Web.UI;
using
System.Web.UI.HtmlControls;
using
System.Web.UI.WebControls;
using
System.Web.UI.WebControls.WebParts;
using
System.Net;
using System.IO;
using
OAuth.Net.Common;
using
OAuth.Net.Components;
using
OAuth.Net.Consumer;
using OAuth;
using
System.Text;
using
System.Xml;
using
System.Collections;
using
System.Collections.Generic;
using
System.Net.Mail;
using System.Text.RegularExpressions;
public partial class test_oauth_test : System.Web.UI.Page
{
string
ConsumerKey = ConfigurationManager.AppSettings["ConsumerKey"].ToString();
string
ConsumerSecret = ConfigurationManager.AppSettings["ConsumerSecret"].ToString();
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;
RegisterStartupScript("refresh", "<script
type='text/javascript'>window.opener.location = 'oauth-test.aspx';
self.close();</script>");
}
else
if (!string.IsNullOrEmpty(OauthVerifier))
{
Button1.Visible = false;
if
(string.IsNullOrEmpty(OauthYahooGuid))
GetAccessToken(OauthToken,
OauthVerifier);
//RefreshToken();
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");
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("http://localhost:7450/GetYahooContact/oauth-test.aspx"));
//Response.Write(sbRequestToken.ToString());
//Response.End();
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)
{
//Response.Redirect(authorizationUrl);
RegisterStartupScript("openwin", "<script
type='text/javascript'>window.open('" + authorizationUrl + "','mywindow',
'left=250,top=50,menubar=0,resizable=0,location=1,toolbar=0,status=1,scrollbars=0,width=500,height=455');</script>");
}
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");
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);
//Response.Write(sbAccessToken.ToString());
//Response.End();
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[] { '&' });
//Response.Write(returnStr);
//Response.End();
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[2].IndexOf("=");
//int
oauth_expires_in;
//Int32.TryParse(returnData[2].Substring(index
+ 1), out oauth_expires_in);
index = returnData[3].IndexOf("=");
string
oauth_session_handle = returnData[3].Substring(index + 1);
OauthSessionHandle =
oauth_session_handle;
//index
= returnData[4].IndexOf("=");
//int
oauth_authorization_expires_in;
//Int32.TryParse(returnData[4].Substring(index
+ 1), out oauth_authorization_expires_in);
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 RefreshToken()
{
OAuthBase
oauth = new OAuthBase();
Uri
uri = new Uri("https://api.login.yahoo.com/oauth/v2/get_token");
string
nonce = oauth.GenerateNonce();
string
timeStamp = oauth.GenerateTimeStamp();
string
sig = ConsumerSecret + "%26" +
OauthTokenSecret;
StringBuilder
sbrefreshToken = new StringBuilder(uri.ToString());
sbrefreshToken.AppendFormat("?oauth_consumer_key={0}&",
ConsumerKey);
sbrefreshToken.AppendFormat("oauth_signature_method={0}&", "PLAINTEXT"); //HMAC-SHA1
sbrefreshToken.AppendFormat("oauth_signature={0}&", sig);
sbrefreshToken.AppendFormat("oauth_timestamp={0}&", timeStamp);
sbrefreshToken.AppendFormat("oauth_version={0}&", "1.0");
sbrefreshToken.AppendFormat("oauth_token={0}&", OauthToken);
sbrefreshToken.AppendFormat("oauth_session_handle={0}&",
OauthSessionHandle);
sbrefreshToken.AppendFormat("oauth_nonce={0}", nonce);
try
{
string
returnStr = string.Empty;
string[]
returnData;
HttpWebRequest
req = (HttpWebRequest)WebRequest.Create(sbrefreshToken.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);
OauthToken = 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);
index = returnData[3].IndexOf("=");
string
oauth_session_handle = returnData[3].Substring(index + 1);
OauthSessionHandle =
oauth_session_handle;
//index
= returnData[4].IndexOf("=");
//int
oauth_authorization_expires_in;
//Int32.TryParse(returnData[4].Substring(index
+ 1), out oauth_authorization_expires_in);
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/" +
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());
//Response.Write("URL:
" + sbGetContacts.ToString());
//Response.End();
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) + "\"";
//Response.Write("</br>Headers:
" + authHeader);
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);
//Response.Write(elemList[i].ChildNodes[2].InnerText
+ "<br/>");
}
grvMyFriends.DataSource = emails;
grvMyFriends.DataBind();
}
#region error
catch (WebException ex)
{
//Response.Write(ex.Message);
Response.Write("<br/>" + ex.Message + "</br>xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
Response.Write("<br/>length: " +
ex.Source.Length.ToString());
Response.Write("<br/>stack trace: " +
ex.StackTrace);
Response.Write("<br/>status: " +
ex.Status.ToString());
HttpWebResponse
res = (HttpWebResponse)ex.Response;
int
code = Convert.ToInt32(res.StatusCode);
Response.Write("<br/>Status Code: (" +
code.ToString() + ") " +
res.StatusCode.ToString());
Response.Write("<br/>Status Description: " +
res.StatusDescription);
if
(ex.InnerException != null)
{
Response.Write("<br/>innerexception: " +
ex.InnerException.Message);
}
if
(ex.Source.Length > 0)
Response.Write("<br/>source: " +
ex.Source.ToString());
if
(res != null)
{
for
(int i = 0; i < res.Headers.Count; i++)
{
Response.Write("<br/>headers: " + i.ToString() + ": " + res.Headers[i]);
}
}
}
#endregion error
}
protected void Button1_Click(object
sender, EventArgs e)
{
string
authorizationUrl = string.Empty;
authorizationUrl = GetRequestToken();
RedirectUserForAuthorization(authorizationUrl);
}
}
