Wednesday, 1 July 2015

MVC Add NewController using T4 Text Template..

When we click on AddNewController-

in background MVC uses T4 Text Templates 'Controller.tt' to create new controller.cs file. 

Location of .tt file is

C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\IDE\ItemTemplates\CSharp\Web\MVC 4\CodeTemplates\AddController\Controller.tt

Tuesday, 30 June 2015

SQL AZURE Database Backup

SQL AZURE Database Backup If We are using Azure SQL Database and in case you want to take back up of existing database for

 1] Before making new deployment or schema changes


 2] or to create a testing database with identical schema and data as existing source db then



 --Script #1 -


Creating a database copy CREATE DATABASE AdventureWorksCopy AS COPY OF AdventureWorks
GO



 --Script #2 - Package wise events

SELECT * FROM sys.dm_database_copies 

 This is an asynchronous operation so you can monitor progress using Script 2 or refresh Management Studio to see expected list of tables.

Tuesday, 18 October 2011

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.

There was an error in this gadget