Handy tool to use when one want to generate insert into statements from the excel data may be helpful to create seedData sql. http://tools.perceptus.ca/text-wiz.php?ops=7

Learn the Fundamentals

JavaScript is Strange!

console.log(1 == true); //true
console.log(1 === true); //false
console.log("0" == false); //true
console.log("abc" == "a" + "b" +"c"); //true
console.log(null == undefined); //true
console.log(30 -"7"); //23
console.log("30" + 7); //307

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

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.

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.