Step by Step Twitter OpenId with DotnetOpenAuth

1] using NuGet a excellent package management system for the Dotnet install DotnetOpenAuth or download it from  SourceForge   DotnetOpenAuth Latest version.

 

2] Then Create your App on Twitter Dev  Do not forget to add Callback URL – if you don’t have anything add  http://www.example.com\mytwitter\

 

3]  you need to use given twitterConsumerKeys and TwitterConsumerSecret keys to request authorisation to your app. Add these keys into Web.config as a appSettings

 

   1: <!-- Twitter sign-up: https://twitter.com/oauth_clients 

   2: --> 

   3:  <add key="twitterConsumerKey" 

   4: value="qjohqNt4kU1iNTQtJSN8Xg" />

   5:  <add 

   6: key="twitterConsumerSecret" value="fo8dzQPx4es0qyULrsmt8IeGWKHndbBvnBtCVp5Hb8" 

   7: />

4] Add below code on Controller Action or on Page Load.

   1:  

   2: var twitter = new 

   3: WebConsumer(TwitterConsumer.ServiceDescription, 

   4: this.TokenManager);

   5:  

   6: // check if Twitter calling back with 

   7: authorization?

   8:  

   9: var accessTokenResponse = 

  10: twitter.ProcessUserAuthorization();

  11:  

  12: if (accessTokenResponse != 

  13: null)

  14:  

  15: {

  16:  

  17: //If you have accesstoek then do 

  18: something 

  19: }

  20:  else if 

  21: (this.AccessToken == 

  22: null)

  23:  

  24: {

  25:  

  26: // If we don't yet have access, immediately request 

  27: it.

  28:  

  29: twitter.Channel.Send(twitter.PrepareRequestUserAuthorization());

  30:  

  31: }

5] add TokenManager

   1:  

   2: private InMemoryTokenManager 

   3: TokenManager

   4:  

   5: {

   6:  

   7: get

   8:  

   9: {

  10:  

  11: var tokenManager = 

  12: (InMemoryTokenManager)Session["TwitterTokenManager"];

  13:  

  14: if (tokenManager == 

  15: null)

  16:  

  17: {

  18:  

  19: string consumerKey = 

  20: ConfigurationManager.AppSettings["twitterConsumerKey"];

  21:  

  22: string consumerSecret = 

  23: ConfigurationManager.AppSettings["twitterConsumerSecret"];

  24:  

  25: if 

  26: (!string.IsNullOrEmpty(consumerKey))

  27:  

  28: {

  29:  

  30: tokenManager = new InMemoryTokenManager(consumerKey, 

  31: consumerSecret);

  32:  

  33: Session["TwitterTokenManager"] = 

  34: tokenManager;

  35:  

  36: }

  37:  

  38: }

  39:  

  40: return 

  41: tokenManager;

  42:  

  43: }

  44:  }

  45:  

  46: 6] and TokenManagerClass

  47: public class InMemoryTokenManager : IConsumerTokenManager, 

  48: IOpenIdOAuthTokenManager

  49:  {

  50:  private 

  51: Dictionary<string, string> tokensAndSecrets = new Dictionary<string, 

  52: string>();

  53:  /// 

  54: <summary>

  55:  /// Initializes a new instance 

  56: of the <see cref="InMemoryTokenManager"/> 

  57: class.

  58:  /// 

  59: </summary>

  60:  /// <param 

  61: name="consumerKey">The consumer 

  62: key.</param>

  63:  /// <param 

  64: name="consumerSecret">The consumer 

  65: secret.</param>

  66:  public 

  67: InMemoryTokenManager(string consumerKey, string 

  68: consumerSecret)

  69:  

  70: {

  71:  if 

  72: (String.IsNullOrEmpty(consumerKey))

  73:  

  74: {

  75:  

  76: throw new 

  77: ArgumentNullException("consumerKey");

  78:  

  79: }

  80:  this.ConsumerKey = 

  81: consumerKey;

  82:  

  83: this.ConsumerSecret = consumerSecret;

  84:  }

  85:  /// 

  86: <summary>

  87:  /// Gets the consumer 

  88: key.

  89:  /// 

  90: </summary>

  91:  /// <value>The consumer 

  92: key.</value>

  93:  public string ConsumerKey { 

  94: get; private set; }

  95:  /// 

  96: <summary>

  97:  /// Gets the consumer 

  98: secret.

  99:  /// 

 100: </summary>

 101:  /// <value>The consumer 

 102: secret.</value>

 103:  public string 

 104: ConsumerSecret { get; private set; }

 105:  #region ITokenManager Members

 106:  /// 

 107: <summary>

 108:  /// Gets the Token Secret 

 109: given a request or access token.

 110:  /// 

 111: </summary>

 112:  /// <param 

 113: name="token">The request or access 

 114: token.</param>

 115:  /// 

 116: <returns>

 117:  /// The secret associated with 

 118: the given token.

 119:  /// 

 120: </returns>

 121:  /// <exception 

 122: cref="ArgumentException">Thrown if the secret cannot be found for the given 

 123: token.</exception>

 124:  public string 

 125: GetTokenSecret(string token)

 126:  

 127: {

 128:  return 

 129: this.tokensAndSecrets[token];

 130:  }

 131:  /// 

 132: <summary>

 133:  /// Stores a newly generated 

 134: unauthorized request token, secret, and 

 135: optional

 136:  /// application-specific parameters 

 137: for later recall.

 138:  /// 

 139: </summary>

 140:  /// <param 

 141: name="request">The request message that resulted in the generation of a new 

 142: unauthorized request token.</param>

 143:  /// 

 144: <param name="response">The response message that includes the unauthorized 

 145: request token.</param>

 146:  /// <exception 

 147: cref="ArgumentException">Thrown if the consumer key is not registered, or a 

 148: required parameter was not found in the parameters 

 149: collection.</exception>

 150:  /// 

 151: <remarks>

 152:  /// Request tokens stored by 

 153: this method SHOULD NOT associate any user account with this 

 154: token.

 155:  /// It usually opens up security holes 

 156: in your application to do so. Instead, you associate a 

 157: user

 158:  /// account with access tokens (not 

 159: request tokens) in the <see 

 160: cref="ExpireRequestTokenAndStoreNewAccessToken"/>

 161:  

 162: /// method.

 163:  /// 

 164: </remarks>

 165:  public void 

 166: StoreNewRequestToken(UnauthorizedTokenRequest request, 

 167: ITokenSecretContainingMessage response)

 168:  

 169: {

 170:  

 171: this.tokensAndSecrets[response.Token] = 

 172: response.TokenSecret;

 173:  }

 174:  /// 

 175: <summary>

 176:  /// Deletes a request token 

 177: and its associated secret and stores a new access token and 

 178: secret.

 179:  /// 

 180: </summary>

 181:  /// <param 

 182: name="consumerKey">The Consumer that is exchanging its request token for an 

 183: access token.</param>

 184:  /// <param 

 185: name="requestToken">The Consumer's request token that should be 

 186: deleted/expired.</param>

 187:  /// <param 

 188: name="accessToken">The new access token that is being issued to the 

 189: Consumer.</param>

 190:  /// <param 

 191: name="accessTokenSecret">The secret associated with the newly issued access 

 192: token.</param>

 193:  /// 

 194: <remarks>

 195:  /// 

 196: <para>

 197:  /// Any scope of granted 

 198: privileges associated with the request token from 

 199: the

 200:  /// original call to <see 

 201: cref="StoreNewRequestToken"/> should be carried 

 202: over

 203:  /// to the new Access 

 204: Token.

 205:  /// 

 206: </para>

 207:  /// 

 208: <para>

 209:  /// To associate a user account 

 210: with the new access token,

 211:  /// <see 

 212: cref="System.Web.HttpContext.User">HttpContext.Current.User</see> may 

 213: be

 214:  /// useful in an ASP.NET web application 

 215: within the implementation of this method.

 216:  /// 

 217: Alternatively you may store the access token here without associating with a 

 218: user account,

 219:  /// and wait until <see 

 220: cref="WebConsumer.ProcessUserAuthorization()"/> 

 221: or

 222:  /// <see 

 223: cref="DesktopConsumer.ProcessUserAuthorization(string, string)"/> return the 

 224: access

 225:  /// token to associate the access token 

 226: with a user account at that point.

 227:  /// 

 228: </para>

 229:  /// 

 230: </remarks>

 231:  public void 

 232: ExpireRequestTokenAndStoreNewAccessToken(string consumerKey, string 

 233: requestToken, string accessToken, string 

 234: accessTokenSecret)

 235:  

 236: {

 237:  

 238: this.tokensAndSecrets.Remove(requestToken);

 239:  

 240: this.tokensAndSecrets[accessToken] = 

 241: accessTokenSecret;

 242:  }

 243:  /// 

 244: <summary>

 245:  /// Classifies a token as a 

 246: request token or an access token.

 247:  /// 

 248: </summary>

 249:  /// <param 

 250: name="token">The token to 

 251: classify.</param>

 252:  /// 

 253: <returns>Request or Access token, or invalid if the token is not 

 254: recognized.</returns>

 255:  public TokenType 

 256: GetTokenType(string token)

 257:  

 258: {

 259:  throw new 

 260: NotImplementedException();

 261:  }

 262:  #endregion

 263:  #region IOpenIdOAuthTokenManager Members

 264:  /// 

 265: <summary>

 266:  /// Stores a new request token 

 267: obtained over an OpenID request.

 268:  /// 

 269: </summary>

 270:  /// <param 

 271: name="consumerKey">The consumer 

 272: key.</param>

 273:  /// <param 

 274: name="authorization">The authorization message carrying the request token and 

 275: authorized access scope.</param>

 276:  /// 

 277: <remarks>

 278:  /// 

 279: <para>The token secret is the empty 

 280: string.</para>

 281:  

 282: /// <para>Tokens stored by this method should be 

 283: short-lived to mitigate

 284:  /// possible security 

 285: threats. Their lifetime should be sufficient for 

 286: the

 287:  /// relying party to receive the positive 

 288: authentication assertion and immediately

 289:  /// 

 290: send a follow-up request for the access 

 291: token.</para>

 292:  /// 

 293: </remarks>

 294:  public void 

 295: StoreOpenIdAuthorizedRequestToken(string consumerKey, 

 296: AuthorizationApprovedResponse authorization)

 297:  

 298: {

 299:  

 300: this.tokensAndSecrets[authorization.RequestToken] = 

 301: String.Empty;

 302:  }

 303:  #endregion

 304:  }

 

now run your code and You will be asked for permission to connect to your twitter account.

Windows Phone7–First Error - Zune

 

While working on windows Phone 7 application if you see below error as

  Zune software is not installed. Install the latest version of Zune software.         0    0   

Change project Build settings from

Windows Phone 7 Device to Windows Phone 7 Emulator.

URL Manipulation in IIS7

Following to my earlier post – on URL Manipulation

For IIS 7 – Can use URL Rewrite Rule -

<rewrite>
  <rules>
    <rule name="HtmlRewrite">
      <match url="(.*)(\.\w+)$" />
      <action type="Rewrite" url="{R:1}" />
    </rule>
  </rules>
</rewrite>

Refer IIS URL rewriting

 "Computers are incredibly fast, accurate and stupid; humans are incredibly slow, inaccurate and brilliant; together they are powerful beyond imagination." -- Albert Einstein

URL Manipulation with RouteBase

2] For URL manipulation  that should ignore the very end extension in url. the extension can be: .html, .aspx, .php

/Home.html should go to Home Controller and 

/Home/index.aspx should go to Home Controller Index Action.

Implement Custom Base entry RouteBase

public class MyUrlRoute : RouteBase
{

    public override RouteData GetRouteData(HttpContextBase httpContext)
    {
        //~/Account/LogOn 
        //~/Home.aspx - Works fine
        //~/home/index.aspx  -Works Fine
        //http://localhost:57282/home/index/1/2/3 - Works fine
        //http://localhost:57282/Account/Register  http://localhost:57282/Account/LogOn - Works Fine

        string url = httpContext.Request.AppRelativeCurrentExecutionFilePath;

        //check null for URL
        const string defaultcontrollername  = "Home";
        string[] spliturl = url.Split("//".ToCharArray());
        string controllername = String.Empty;
        string actionname = "Index";



        if (spliturl.Length == 2) //for ~/home.aspx and ~/ 
        {
            if (String.IsNullOrEmpty(spliturl[1])) //TODO:  http://localhost:57282/ not working - to make it working
            {
                controllername = defaultcontrollername;
            }
            else
            {
                controllername = spliturl[1];
                if (controllername.Contains("."))
                {
                    controllername = controllername.Substring(0, controllername.LastIndexOf("."));
                }
            }
        }
        else if (spliturl.Length == 3) // For #/home/index.aspx and /home/about
        {
            controllername = spliturl[1];
            actionname = spliturl[2];
            if (actionname.Contains("."))
            {
                actionname = actionname.Substring(0, actionname.LastIndexOf("."));
            }
        }
        else //final block in final case sned it to Home Controller
        {
            controllername = defaultcontrollername;
        }


        RouteData rd = new RouteData(this, new MvcRouteHandler());
        rd.Values.Add("controller", controllername);
        rd.Values.Add("action", actionname);
        rd.Values.Add("url", url);
        return rd;
    }

    public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
    {
        return null;
    }

and in global.aspx add below code.

    public static void RegisterRoutes(RouteCollection routes)
    {
        routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

        routes.Add(new MyUrlRoute()); // Add before your default Routes

        routes.MapRoute(
            "Default", // Route name
            "{controller}/{action}/{id}", // URL with parameters
            new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
        );

    }

Refer SO question

References. :

    // Implementing Custom Base entry - Pro Asp.Net MVc Framework       
    //- http://books.google.com/books?id=tD3FfFcnJxYC&pg=PA251&lpg=PA251&dq=.net+RouteBase&source=bl&ots=IQhFwmGOVw&sig=0TgcFFgWyFRVpXgfGY1dIUc0VX4&hl=en&ei=z61UTMKwF4aWsgPHs7XbAg&sa=X&oi=book_result&ct=result&resnum=6&ved=0CC4Q6AEwBQ#v=onepage&q=.net%20RouteBase&f=false       
    // phil haack's Route Debugger http://haacked.com/archive/2008/03/13/url-routing-debugger.aspx

URL Routing default.aspx ASP.NET MVC

1] In case if  Default.aspx need to be a start up page for  MVC project then 

Add  a new WebForm as a Default.aspx in Root directory ,

set it as Start up page

and on Page Load redirect it to your default URL. -

public partial class _default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        Response.Redirect("~/Home");
    }
}