public DbMigratorEventArgs(DbMigrationsConfiguration migrationConfiguration)
        {
            this.MigrationConfiguration = migrationConfiguration;

            DbMigrator migrator = new DbMigrator(migrationConfiguration);
            this.PendingMigrations = migrator.GetPendingMigrations();
            this.CompletedMigrations = migrator.GetDatabaseMigrations();
        }

        public static void RegisterAuth()
        {
            var migrator = new DbMigrator(new Configuration());
            migrator.Update();

               if (!WebSecurity.Initialized)
               {
               WebSecurity.InitializeDatabaseConnection("AnunciosDbContext", "UserProfile", "UserId",
                                                       "UserName", autoCreateTables: true);
            }
            // To let users of this site log in using their accounts from other sites such as Microsoft, Facebook, and Twitter,
            // you must update this site. For more information visit http://go.microsoft.com/fwlink/?LinkID=252166

            //OAuthWebSecurity.RegisterMicrosoftClient(
            //    clientId: "",
            //    clientSecret: "");

            //OAuthWebSecurity.RegisterTwitterClient(
            //    consumerKey: "",
            //    consumerSecret: "");

            //OAuthWebSecurity.RegisterFacebookClient(
            //    appId: "",
            //    appSecret: "");

            //OAuthWebSecurity.RegisterGoogleClient();
        }

        public static void ConfigureMobileApp(IAppBuilder app)
        {
            HttpConfiguration config = new HttpConfiguration();

            //For more information on Web API tracing, see http://go.microsoft.com/fwlink/?LinkId=620686
            config.EnableSystemDiagnosticsTracing();

            new MobileAppConfiguration().UseDefaultConfiguration().ApplyTo(config);

            // Use Entity Framework Code First to create database tables based on your DbContext
            // Database.SetInitializer(new mouselightInitializer());
            var migrator = new DbMigrator(new Janelia.Mouse.Mobile.Server.Migrations.Configuration());
            migrator.Update();

            // To prevent Entity Framework from modifying your database schema, use a null database initializer
            // Database.SetInitializer<MouseLightContext>(null);

            MobileAppSettingsDictionary settings = config.GetMobileAppSettingsProvider().GetMobileAppSettings();

            if (string.IsNullOrEmpty(settings.HostName))
            {
                // This middleware is intended to be used locally for debugging. By default, HostName will
                // only have a value when running in an App Service application.
                app.UseAppServiceAuthentication(new AppServiceAuthenticationOptions
                {
                    SigningKey = ConfigurationManager.AppSettings["SigningKey"],
                    ValidAudiences = new[] { ConfigurationManager.AppSettings["ValidAudience"] },
                    ValidIssuers = new[] { ConfigurationManager.AppSettings["ValidIssuer"] },
                    TokenHandler = config.GetAppServiceTokenHandler()
                });
            }

            app.UseWebApi(config);
        }

        private static void RunUpdate(string connectionName)
        {
            Console.WriteLine("RUNNING MIGRATIONS FOR CONNECTION NAME: " + connectionName);

            var configuration = new Configuration();

            configuration.TargetDatabase =
                new DbConnectionInfo(connectionName);

            try
            {
                Console.WriteLine("TRYING...");
                var migrator = new DbMigrator(configuration);

                migrator.Update();
                Console.WriteLine("SUCCESS!");
                ExitCode = 1;
            }
            catch (Exception ex)
            {
                Console.WriteLine("EXCEPTION:");
                Console.WriteLine(ex.Message);
                Console.WriteLine("FAILURE!");
            }

            Console.WriteLine("DONE!");
            Environment.Exit(ExitCode);
        }

        public static void Main(string[] args)
        {
            Console.WriteLine(@"Migrating database...");
            var migrator = new DbMigrator(new Configuration());
            Console.WriteLine(@"Connection: " + GetConnectionString(migrator));

            var migrations = migrator.GetPendingMigrations().ToList();

            if (!migrations.Any()) {
                Console.WriteLine(@"No pending migrations.");
            } else {
                foreach (var migration in migrations) {
                    Console.WriteLine(migration);
                    migrator.Update(migration);
                }
            }

            if (args.Contains("--seed")) {
                Console.WriteLine(@"Seeding the database...");
                var context = new EntityContext();

                DatabaseSeeder.Seed(context);

                context.SaveChanges();
            } else {
                Console.WriteLine(@"No seeding required.");
            }
            Console.WriteLine(@"Migration done.");
        }

        public void InitializeDatabase()
        {
            var configuration = new Configuration();

            var migrator = new DbMigrator(configuration);
            migrator.Update();
        }

        public QueueFixture()
        {
            try
            {
                var configuration = new DbMigrationsConfiguration
                {
                    ContextType = typeof(QueueDataContext),
                    MigrationsAssembly = typeof(QueueDataContext).Assembly,
                    TargetDatabase = new DbConnectionInfo("QueueDataContext"),
                    MigrationsNamespace = typeof(InitialCreate).Namespace,
                    AutomaticMigrationDataLossAllowed = true
                };

                var migrator = new DbMigrator(configuration);
                //Update / rollback to "MigrationName"
                migrator.Update("0");
                migrator.Update();
                _sut = new SqlQueueImpl(new Infrastructure.DatabaseContextFactory());
            }
            catch (Exception ex)
            {
                if (Debugger.IsAttached) Debugger.Break();
                Console.WriteLine(ex);
                throw;
            }
        }

        private static void RunMigrations()
        {
            var efMigrationSettings = new HomeManager.Domain.Migrations.Configuration();
            var efMigrator = new DbMigrator(efMigrationSettings);

            efMigrator.Update();
        }

        protected void Application_Start()
        {
            var connString = ConfigurationManager.ConnectionStrings["BlogContext"];
            string commandText = @"
            CREATE TABLE [__MigrationHistory] (
            [Id] [uniqueidentifier] DEFAULT newid(),
            [Migration] [nvarchar](255) NOT NULL,
            [CreatedOn] [datetime] NOT NULL,
            [Hash] [binary](32) NOT NULL,
            [Model] [varbinary](max) NOT NULL,
            PRIMARY KEY ([Id])
            );
            ";
            using (var connection = new SqlConnection(connString.ConnectionString)) {
                using (var command = new SqlCommand(commandText, connection)) {
                    connection.Open();
                    try {
                        command.ExecuteNonQuery();
                    }
                    catch {
                    }
                }
            }

            var dbMigrator = new DbMigrator(new MvcApplicationCodeFirst.Migrations.Settings());
            dbMigrator.Update();

            AreaRegistration.RegisterAllAreas();

            RegisterGlobalFilters(GlobalFilters.Filters);
            RegisterRoutes(RouteTable.Routes);
        }

 public static DbMigrator GetMigrator(TestContext testContext)
 {
     var configuration = new Configuration();
     configuration.TargetDatabase = new DbConnectionInfo("DefaultConnection");
     var migrator = new DbMigrator(configuration);
     return migrator;
 }

 public static string CreateScriptFromMigration()
 {
     var migrationConfig = new Configuration();
     var migrator = new DbMigrator(migrationConfig);
     var scriptor = new MigratorScriptingDecorator(migrator);
     return scriptor.ScriptUpdate(sourceMigration: null, targetMigration: null);
 }

        protected void Application_Start()
        {
            var migrator = new DbMigrator(new Configuration());
            migrator.Configuration.AutomaticMigrationDataLossAllowed = true;
            migrator.Update();

            //Database.SetInitializer<ApplicationDbContext>(new AppDbInitializer());
            AreaRegistration.RegisterAllAreas();
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            BundleMobileConfig.RegisterBundles(BundleTable.Bundles);
            ModelBinders.Binders.Add(typeof(Cart), new CartModelBinder());
            ControllerBuilder.Current.SetControllerFactory(new NinjectControllerFactory());

            DisplayModeProvider.Instance.Modes.Insert(0, new DefaultDisplayMode("iphone")
            {
                ContextCondition = Context =>
                                Context.Request.Browser["HardwareModel"] == "iPhone"
            });

            DisplayModeProvider.Instance.Modes.Insert(1, new DefaultDisplayMode("android")
            {
                ContextCondition = Context =>
                                Context.Request.Browser["PlatformName"] == "Android"
            });

            DisplayModeProvider.Instance.Modes.Insert(2, new DefaultDisplayMode("mobile")
            {
                ContextCondition = Context =>
                                Context.Request.Browser["IsMobile"] == "True"
            });
        }

 public static void GenerateSqlUsingDbMigrator()
 {
     using (var context = new AdventureWorksContext())
     {
         var configuration = new Configuration
             {
                 ContextType = typeof(AdventureWorksContext),
                 TargetDatabase =
                     new DbConnectionInfo(context.Database.Connection.ConnectionString, "System.Data.SqlClient")
             };
         var migrator = new DbMigrator(configuration);
         var migrations = migrator.GetDatabaseMigrations();
         if (migrations.Any())
         {
             var scriptor = new MigratorScriptingDecorator(migrator);
             string script = scriptor.ScriptUpdate(null, migrations.Last());
             if (!String.IsNullOrEmpty(script))
             {
                 Console.WriteLine(script);
                 //context.Database.ExecuteSqlCommand(script);
             }
         }                
         
         Console.ReadKey();
     }
 }

        public static void Run()
        {
            ConsoleLogger.Information("Installing Database");
            using (var context = new DataContext())
            {
                try
                {
                    ConsoleLogger.Information("  Dropping database...");
                    context.Database.Delete();
                }
                catch (Exception ex)
                {
                    ConsoleLogger.Error("  Error: Could not drop database! " + ex);
                }

                try
                {
                    ConsoleLogger.Information("  Creating database...");
                    var migrator = new DbMigrator(new ClaimDbConfiguration());
                    migrator.Update();
                }
                catch (Exception ex)
                {
                    ConsoleLogger.Error("  Error: Could not create database! " + ex);
                }
            }

            ConsoleLogger.Information("Database Installed!");
        }

 public MainContext(string connectionString)
     : base(connectionString)
 {
     ConnectionString = connectionString;
     _Migrator = new DbMigrator(this.GetDbMigrationsConfiguration());
     logger = NLog.LogManager.GetCurrentClassLogger();
 }

        public string Run(string from, string to)
        {
            var configuration = new Configuration();

            //Can set the Target Database to be in another Server or Environment
            //configuration.TargetDatabase =
            //    new DbConnectionInfo("Server=.;Database=Investment;Trusted_Connection=True;",
            //        "System.Data.SqlClient");

            //var context = (InvestmentContext)Activator.CreateInstance(configuration.ContextType);
            var runUpdate = false;

            var migrator = new DbMigrator(configuration);

            var scriptor = new MigratorScriptingDecorator(migrator);
            var sql = scriptor.ScriptUpdate("", "");
            //var sql = scriptor.ScriptUpdate("Name-Of-Source-Migration", "Name-Of-Target-Migration");
            //configuration.RunSeedProcess(context);

            if (runUpdate)
            {
                //Can run the update from here
                migrator.Update(); //Could add a "TargetMigration"
            }

            return sql;
        }

        private static void RunMigrations()
        {
            var efMigrationSettings = new ShippingExpress.Domain.Migrations.Configuration();
            var efMigrator = new DbMigrator(efMigrationSettings);

            efMigrator.Update();
        }

        private static void RunMigrations() {

            var efMigrationSettings = new PingYourPackage.Domain.Migrations.Configuration();
            var efMigrator = new DbMigrator(efMigrationSettings);

            efMigrator.Update();
        }

        private static void UpdateDb()
        {
            var settings = new Configuration();
            var migrator = new DbMigrator(settings);

            migrator.Update();
        }

        /// <summary>
        /// Creates a new database file at the specified path with the specified file name.
        /// The ".sdf" extension will be added to the file. Do not pass it in the file name.
        /// </summary>
        /// <param name="databaseFilePath">The path to the file, excluding the file's name</param>
        /// <param name="databaseFileName">The name of the new database file. Exclude the .sdf extension - it will be added automatically.</param>
        /// <param name="changeApplicationConnection">If true, the application's connection will be changed to this new database.</param>
        /// <returns>Returns the full path to the database file.</returns>
        public string CreateNewDatabase(string databaseFilePath, string databaseFileName, bool changeApplicationConnection)
        {
            string fullPath = databaseFilePath + "\\" + databaseFileName + ".sdf";
            string connectionString;

            // Update connection settings and the active module directory path
            if (changeApplicationConnection)
            {
                ChangeDatabaseConnection(fullPath);
                WinterConnectionInformation.ActiveModuleDirectoryPath = fullPath;
                connectionString = WinterConnectionInformation.ActiveConnectionString;
            }
            // Otherwise we're simply creating a new database file. Build a connection string.
            else
            {
                connectionString = BuildConnectionString(fullPath);
            }

            // Initialize the database - will create the database file at the specified location.
            // Also creates tables based on the code-first model.
            using (ModuleDataContext context = new ModuleDataContext(connectionString))
            {
                DbMigrator migrator = new DbMigrator(new ModuleDataContextMigrationConfiguration());
                migrator.Update();
            }

            return fullPath;
        }