Import Yahoo Contacts In C#

Posted: July 28, 2012 in ASP.net, C#
Tags: , , , ,
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.

Advertisements
Comments
  1. sagar says:

    The remote server returned an error: (400) Bad Request.

  2. of course like your website but you have to check the spelling on several of your posts. A number of them are rife with spelling problems and I to find it very bothersome to tell the reality then again I will definitely come again again.

  3. rajesh says:

    can any one tell … where do i give d userid and password in this code

  4. when you will click on button in html page , you will be redirected to yahoo sign in page..

    • rajesh says:

      no it didnt redirected to signin page, when i exec d code RedirectUserForAuthorization(authorizationUrl); authorizationUrl returns null tat is the problem i think

    • dead says:

      hello Mr. dotnetgeekblog, this code is helpful and works fine.

      i have some questions:

      1 – have an way to redirect that login page and confirm to inside an iframe?
      i had implemented this: inside my default.aspx i have the button and the grid, but when i click on button don’t opened the login page on iframe, i think because i don’t have an https connection. If u have an idea plz help me!

      2 – i want verify if the contact returned by grid is a friend because i want send an e-mail for they, but i don’t will send e-mail for contacts that don’t are friend. An example is google api… i just verify if the returned contact have an name, if not they aren’t friends.

      in yahoo to grab the e-mail adress is used “elemList(i).ChildNodes(2).InnerText”

      i try to use ChildNodes() using 0, 1 and 2 in elemList(i), but nothing.

      Thanks a lot.

  5. al says:

    No where in the code is there a link to redirect you to the yahoo login page.
    I think this is the problem:

    Page.ClientScript.RegisterStartupScript(typeof(ScriptManager), “refresh”, “// “);

    Is there suppose to be an additional java script file to redirect you to the yahoo login page?

    • al says:

      I got it to work. Replace both Page.ClientScript lines with this: one for openwin and the other for refresh

      Page.ClientScript.RegisterStartupScript(typeof(ScriptManager),”openwin”, “window.open(‘” + authorizationUrl + “‘,’mywindow’, ‘left=250,top=50,menubar=0,resizable=0,location=1,toolbar=0,status=1,scrollbars=0,width=500,height=455’);”);

      Page.ClientScript.RegisterStartupScript(typeof(ScriptManager),”refresh”, “window.opener.location = ‘oauth-test.aspx’; self.close();”);

  6. Lav says:

    Hello dotnetgeek,
    The code provided here is to import yahoo contacts list using C#. But I need it using Java. So if please if you can help me. If you can give me the Java code or some other link(website) which helps me in doing that.

    Your help would highly be appreciated.

  7. Bindu says:

    I am getting this error: The remote server returned an error: (400) Bad Request. how can i get rid of this error. Help me in this aspect sir. waiting for u reply

  8. so2014.com says:

    Hi mates, its great post on the topic of educationand fully
    explained, keep it up all the time.

  9. Unquestionably consider that which you said. Your
    favourite justification seemed to be at the web
    the easiest thing to have in mind of. I say to you, I certainly
    get annoyed while other people consider concerns that they plainly
    do not recognise about. You controlled to hit the nail upon the highest as neatly
    as outlined out the entire thing with no need side effect
    , other people could take a signal. Will probably be again to get more.

    Thanks

  10. segi says:

    I got “The remote server returned an error: (404) Not Found. ” error from GetRequestToken method. I have changed my redirect url only. can u please help me where i m wrong ?

  11. Pankaj Kumar says:

    Hi All,
    I got this error every time.
    The remote server returned an error: (401) Unauthorized.
    so please tell me that what should i do?.
    please tell me the way to get the right solution.its very important for me.

  12. sreedhar says:

    its nice article..how can i get Name and MobileNumbers from yahoo

  13. sreedhar says:

    it How to get names and mobile number from this code

  14. siva says:

    gud mng sir..
    in javascript,import contacts possible?if it is possible..please send this code for me sir please

  15. Srinu says:

    The remote server returned an error: (404) Not Found. How to solve the problem……

  16. Anirudh says:

    Getting error 401 unauthorized

  17. kiquenet says:

    Any updates about it ? Unit test sample not ASP.NET ?

  18. The particular agario hack into does this all
    for you personally.. It is an online *multiplayer match
    that could be actually used by a many more than buyers all together.

  19. Guarded by Samsung KNOX, fingerprint scanning and advanced tokenisation, Samsung Pay works
    together with both NFC and MST technology.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s