public void AbstractScriptedIndexCreationTaskWillCreateIndexAndDocument1() { using (var store = NewDocumentStore()) { IndexCreation.CreateIndexes(new CompositionContainer(new TypeCatalog(typeof(People_By_Name_With_Scripts))), store); var index = new People_By_Name_With_Scripts(); var indexDefinition = store.DatabaseCommands.GetIndex(index.IndexName); Assert.NotNull(indexDefinition); using (var session = store.OpenSession()) { var indexDocument = session.Load <ScriptedIndexResults>(ScriptedIndexResults.IdPrefix + index.IndexName); Assert.NotNull(indexDocument); Assert.Equal(index.DeleteScript, indexDocument.DeleteScript); Assert.Equal(index.IndexScript, indexDocument.IndexScript); Assert.Equal(index.RetryOnConcurrencyExceptions, indexDocument.RetryOnConcurrencyExceptions); Assert.Equal(ScriptedIndexResults.IdPrefix + index.IndexName, indexDocument.Id); } } }
protected ServiceStackTestBase() { DocumentStore = NewDocumentStore(); IndexCreation.CreateIndexes(typeof(ServiceStackTestBase).Assembly, DocumentStore); IndexCreation.CreateIndexes(typeof(RavenUserAuthRepository).Assembly, DocumentStore); Host = new TestAppHost(DocumentStore); Host.Init(); Host.Start(ListeningOn); Client = new JsonServiceClient(ListeningOn) { AlwaysSendBasicAuthHeader = true, UserName = Username, Password = Password }; RegisterUser(); WaitForIndexing(DocumentStore); }
/// <summary> /// Configure IoC, register all dependencies /// </summary> protected virtual void ConfigureIocContainer(IServiceCollection services) { services.RegisterModules(Assembly.GetAssembly(typeof(BaseService <>)) !); // Register the document store & session services.AddScoped(_ => { IDocumentStore store = GetDocumentStore(); // Create all indexes IndexCreation.CreateIndexes(typeof(SetupDocumentStore).Assembly, store, null, store.Database); return(store); }); services.AddScoped(c => { var session = c.GetService <IDocumentStore>() !.OpenAsyncSession(new SessionOptions { NoCaching = true }); session.Advanced.WaitForIndexesAfterSaveChanges(); // Wait on each change to avoid adding WaitForIndexing() in each test return(session); }); }
public static IDocumentStore CreateDocumentStore() { try { ServiceStartupLogger.LogMessage("Start RavenHelper.CreateDocumentStore, creating document store"); var documentStore = new DocumentStore { ConnectionStringName = "RavenDB", Conventions = { FindTypeTagName = type => { if (typeof(SettingsBase).IsAssignableFrom(type)) { return("SettingsBases"); } if (typeof(ConnectionSettingBase).IsAssignableFrom(type)) { return("ConnectionSettingBases"); } return(DocumentConvention.DefaultTypeTagName(type)); }, MaxNumberOfRequestsPerSession = AppSettingsHelper.GetIntSetting("RavenMaxNumberOfRequestsPerSession", 30000) } }; ServiceStartupLogger.LogMessage("RavenHelper.CreateDocumentStore, calling Initialize"); documentStore.Initialize(); ServiceStartupLogger.LogMessage("RavenHelper.CreateDocumentStore, creating indexes"); IndexCreation.CreateIndexes(typeof(MMDB.DataService.Data.Jobs.DataServiceJobBase <>).Assembly, documentStore); ServiceStartupLogger.LogMessage("RavenHelper.CreateDocumentStore, diabling all caching"); documentStore.DatabaseCommands.DisableAllCaching(); ServiceStartupLogger.LogMessage("Done RavenHelper.CreateDocumentStore"); return(documentStore); } catch (Exception err) { ServiceStartupLogger.LogMessage("RavenHelper.CreateDocumentStore error: " + err.ToString()); throw; } }
static IDocumentStore CreateStore() { var s1 = new DocumentStore() { Url = "http://localhost:8080", DefaultDatabase = "S1" }.Initialize(); var s2 = new DocumentStore() { Url = "http://localhost:8081", DefaultDatabase = "S2" }.Initialize(); var strategy = new ShardStrategy(new Dictionary <String, IDocumentStore>() { { "S1", s1 }, { "S2", s2 } }); strategy.ShardingOn <Order>(o => o.Country, c => { if (c.Equals("italy", StringComparison.OrdinalIgnoreCase)) { return("S1"); } return("S2"); }); strategy.ShardingOn <Person>(); var store = new ShardedDocumentStore(strategy) { }.Initialize(); IndexCreation.CreateIndexes(Assembly.GetExecutingAssembly(), store); return(store); }
public DocumentStoreHolder(IOptions <RavenSettings> ravenSettings, ILogger <DocumentStoreHolder> logger) { this._logger = logger; var settings = ravenSettings.Value; Store = new DocumentStore() { Urls = new[] { settings.Url }, Database = settings.Database }; Store.Initialize(); this._logger.LogInformation("🌟 Initialized RavenDB document store for {0} at {1}", settings.Database, settings.Url); // Create if not exists CreateDatabaseIfNotExists(); // Create indexes IndexCreation.CreateIndexes(typeof(Talks_BySpeaker).Assembly, Store); }
protected RavenControllerTest() { //NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8081); documentStore = new EmbeddableDocumentStore { RunInMemory = true, //UseEmbeddedHttpServer = true, }; documentStore.RegisterListener(new NoStaleQueriesAllowed()); documentStore.Initialize(); IndexCreation.CreateIndexes(typeof(BusStop_Spatial).Assembly, documentStore); Controller = new TController { RavenSession = documentStore.OpenSession() }; var httpContext = Substitute.For <HttpConfiguration>(); var httpRoute = Substitute.For <HttpRouteData>(Substitute.For <IHttpRoute>()); Controller.ControllerContext = new HttpControllerContext(httpContext, httpRoute, new HttpRequestMessage()); }
protected void Application_Start() { GlobalConfiguration.Configure(WebApiConfig.Register); var formatters = GlobalConfiguration.Configuration.Formatters; var jsonFormatter = formatters.JsonFormatter; var settings = jsonFormatter.SerializerSettings; settings.Converters.Add(new IsoDateTimeConverter()); settings.Formatting = Formatting.Indented; settings.ContractResolver = new CamelCasePropertyNamesContractResolver(); Store = new DocumentStore { ConnectionStringName = "RavenDB" }; Store.Initialize(); RavenDbErrorLog.ConfigureWith(Store); AutomappingConfiguration.Bootstrap(); //RavenProfiler.InitializeFor(Store); IndexCreation.CreateIndexes(typeof(HomeController).Assembly, Store); ConventionsBootstrapper.Bootstrap(); ObjectSummarizer.KeyProviders.Add(new RegisteredKeyProvider() { Provider = new DbKeyFieldAsClassPropertyKeyProvider() }); ObjectSummarizer.DescriptionProviders.Add(new RegisteredDescriptionProvider() { Provider = new NameOrDescriptionProperty() }); RegisterGlobalFilters(GlobalFilters.Filters); RegisterRoutes(RouteTable.Routes); AreaRegistration.RegisterAllAreas(); }
private static IDocumentStore BuildDocumentStore(string rootDir, int?studioPort) { EmbeddedServer.Instance.StartServer(new ServerOptions { DataDirectory = rootDir, ServerUrl = "http://127.0.0.1:" + studioPort, }); IDocumentStore documentStore = EmbeddedServer.Instance.GetDocumentStore(new DatabaseOptions("Embedded") { Conventions = new DocumentConventions() { MaxNumberOfRequestsPerSession = 100, }, }); documentStore.Initialize(); IndexCreation.CreateIndexes(typeof(Program).Assembly, documentStore); return(documentStore); }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); //var b = new ScriptBundle("~/bundles/kendo").Include( // "~/Scripts/kendo*"); //b.IncludeDirectory("~/Scripts/kendo"); //BundleTable.Bundles.Add(b); //var root = new MeetingCompositionRoot(); //ControllerBuilder.Current.SetControllerFactory(root.ControllerFactory); Store = new DocumentStore { ConnectionStringName = "RavenDB" }; Store.Initialize(); IndexCreation.CreateIndexes(Assembly.GetCallingAssembly(), Store); }
public void write_then_read_from_complex_entity_types_lazily() { using (GetNewServer()) using (var store = new DocumentStore { Url = "http://localhost:8080" }.Initialize()) { IndexCreation.CreateIndexes(typeof(QuestionWithVoteTotalIndex).Assembly, store); string answerId = ComplexValuesFromTransformResults.CreateEntities(store); // Working using (IDocumentSession session = store.OpenSession()) { var answerInfo = session.Query <Answer, Answers_ByAnswerEntity>() .Customize(x => x.WaitForNonStaleResultsAsOfNow()) .Where(x => x.Id == answerId) .As <AnswerEntity>() .Lazily(); Assert.NotNull(answerInfo.Value.ToArray().Length); } } }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); //DocumentStore = (DocumentStore)(new DocumentStore //{ // Url = "http://localhost:23456", // DefaultDatabase = "RavenStore" //}).Initialize(); DocumentStore = new DocumentStore { Url = "http://localhost:23456" }; DocumentStore.DefaultDatabase = "RavenStore"; DocumentStore.Initialize(); IndexCreation.CreateIndexes(typeof(Products_ByCategory).Assembly, DocumentStore); }
static void Main(string[] args) { using (var store = new DocumentStore { Url = "http://localhost:8080" }.Initialize()) { IndexCreation.CreateIndexes(typeof(Users_ByName).Assembly, store); using (var session = store.OpenSession()) { var names = new[] { "Oren Eini", "Ayende Rahien", "Yoal", "Ido", "Yaron", "Oded Haim", "Michael Rer", "Gal Rotem", "Udi Dahan", "Roy Osherove", "Haim Aharon", "Arava Eini" }; foreach (var name in names) { session.Store(new User { Name = name }); } session.SaveChanges(); } while (true) { using (var session = store.OpenSession()) { Console.Write("Enter user name: "); var name = Console.ReadLine(); PerformQuery(session, name); } } } }
public new void SetUp() { var store = GetDocumentStore(); store.Initialize(); IndexCreation.CreateIndexes(typeof(Record).Assembly, store); WaitForIndexing(store); ReusableDocumentStore = store; Db = ReusableDocumentStore.OpenSession(); var record1 = SimpleRecord().With(m => { m.Gemini.Title = "sea"; m.Gemini.DatasetReferenceDate = "2017-10-10"; }); var record2 = SimpleRecord().With(m => { m.Gemini.Title = "seabirds"; m.Gemini.DatasetReferenceDate = "2017-10-19"; }); var record3 = SimpleRecord().With(m => { m.Gemini.Title = "birds"; m.Gemini.DatasetReferenceDate = "2017-10-15"; }); var record4 = SimpleRecord().With(m => { m.Gemini.Title = "coastal birds"; m.Gemini.DatasetReferenceDate = "2017-10-17"; }); Db.Store(record1); Db.Store(record2); Db.Store(record3); Db.Store(record4); Db.SaveChanges(); WaitForIndexing(ReusableDocumentStore); }
static void Main(string[] args) { using (var docStore = new DocumentStore { Url = "http://localhost.fiddler:8080", DefaultDatabase = "Users" }.Initialize()) { IndexCreation.CreateIndexes(typeof(User).Assembly, docStore); while (true) { var search = Console.ReadLine(); using (var session = docStore.OpenSession()) { DoQueryForUsers(session, search); } } } }
private void TryCreatingIndexes(string connectionString) { try { store.DatabaseCommands.EnsureDatabaseExists("Dexter"); Setup.Indexes.UpdateDatabaseIndexes(store); IndexCreation.CreateIndexes(this.GetType().Assembly, store); } catch (WebException e) { var socketException = e.InnerException as SocketException; if (socketException == null) { throw; } switch (socketException.SocketErrorCode) { case SocketError.AddressNotAvailable: case SocketError.NetworkDown: case SocketError.NetworkUnreachable: case SocketError.ConnectionAborted: case SocketError.ConnectionReset: case SocketError.TimedOut: case SocketError.ConnectionRefused: case SocketError.HostDown: case SocketError.HostUnreachable: case SocketError.HostNotFound: throw new DexterDatabaseConnectionException("Unable to connect to RavenDB", socketException, connectionString); default: throw; } } }
public void object_id_should_not_be_null_after_loaded_from_transformation() { using (EmbeddableDocumentStore documentStore = NewDocumentStore()) { IndexCreation.CreateIndexes(typeof(QuestionWithVoteTotalIndex).Assembly, documentStore); const string questionId = @"question\259"; string answerId = CreateEntities(documentStore); using (IDocumentSession session = documentStore.OpenSession()) { AnswerEntity answerInfo = session.Query <Answer, Answers_ByAnswerEntity>() .Customize(x => x.WaitForNonStaleResultsAsOfNow()) .Where(x => x.Id == answerId) .As <AnswerEntity>() .SingleOrDefault(); Assert.NotNull(answerInfo); Assert.NotNull(answerInfo.Question); Assert.NotNull(answerInfo.Question.Id); Assert.True(answerInfo.Question.Id == questionId); } } }
public void Multiple_indexes_created_with_not_existing_analyzer_should_skip_only_the_invalid_index() { using (var store = NewRemoteDocumentStore()) { var indexManager = new IndexManager(); var container = new CompositionContainer(); container.ComposeParts(indexManager, new Index1(), new Index2(), new Index3()); try { IndexCreation.CreateIndexes(container, store); } catch (AggregateException e) { Assert.Contains("Index2", e.InnerExceptions.First().Message); } var indexInfo = store.DatabaseCommands.GetStatistics().Indexes; Assert.Equal(3, indexInfo.Length); //the third is Raven/DocumentEntityByName Assert.True(indexInfo.Any(index => index.Name.Equals("Index1"))); Assert.True(indexInfo.Any(index => index.Name.Equals("Index3"))); } }
static void Main() { using (var documentStore = new DocumentStore { Url = "http://localhost:8080" }.Initialize()) { using (var session = documentStore.OpenSession()) { IndexCreation.CreateIndexes(typeof(Posts_ByTitle).Assembly, documentStore); var postsBySearch = session.Query <Post, Posts_ByTitle>() .Search(x => x.Title, "Code*") .OrderByDescending(x => x.PostDate).ToList(); foreach (var post in postsBySearch) { Console.WriteLine("Post ID: {0}, Title: {1}", post.Id, post.Title); } Console.ReadKey(true); } } }
private static IDocumentStore CreateDocumentStore() { var machineName = ConfigurationManager.AppSettings["Machine"]; if (machineName == Environment.MachineName) { var service = new ServiceController("ProductivityTracker_Raven", machineName); if (service.Status == ServiceControllerStatus.Stopped) { service.Start(); service.WaitForStatus(ServiceControllerStatus.Running, TimeSpan.FromSeconds(60)); } } var store = new DocumentStore { Url = string.Format("http://{0}:8080", machineName) }; store.Initialize(); IndexCreation.CreateIndexes(typeof(RecruiterIndex).Assembly, store); return(store); }
private void AddRavenDBServices(IServiceCollection services) { services.AddSingleton <IDocumentStore> (s => { IDocumentStore store = new DocumentStore() { Urls = new [] { Configuration.GetValue <string> ("RavenDBEndpoint") }, Database = Configuration.GetValue <string> ("RavenDBDataBase") }; store.Conventions.FindCollectionName = type => { if (typeof(TossEntity).IsAssignableFrom(type)) { return("TossEntity"); } return(DocumentConventions.DefaultGetCollectionName(type)); }; store.Initialize(); //taken from https://ravendb.net/docs/article-page/4.1/csharp/client-api/operations/server-wide/create-database try { store.Maintenance.ForDatabase(store.Database).Send(new GetStatisticsOperation()); } catch (DatabaseDoesNotExistException) { try { store.Maintenance.Server.Send(new CreateDatabaseOperation(new DatabaseRecord(store.Database))); } catch (ConcurrencyException) { // The database was already created before calling CreateDatabaseOperation } } IndexCreation.CreateIndexes(typeof(Startup).Assembly, store); return(store); }); services.AddScoped(s => s.GetRequiredService <IDocumentStore> ().OpenAsyncSession()); services.AddSingleton <RavenDBIdUtil> (); services .AddRavenDbIdentity <ApplicationUser> (); }
private IDocumentStore InitDocumentStore(AutofacCreationConverter converter) { var ds = new EmbeddableDocumentStore { DataDirectory = _dataDirectory, ResourceManagerId = Guid.NewGuid(), RunInMemory = RunInMemory, }; if (_httpAccesss) { ds.UseEmbeddedHttpServer = true; NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(_httpAccesssPort); } if (converter != null && UseCreationConverter) { ds.Conventions.CustomizeJsonSerializer += s => s.Converters.Add(converter); } ds.Conventions.DisableProfiling = true; ds.Conventions.JsonContractResolver = new RecordClrTypeInJsonContractResolver(); ds.Conventions.CustomizeJsonSerializer += s => s.TypeNameHandling = TypeNameHandling.Arrays; ds.Initialize(); IndexCreation.CreateIndexes(ThisAssembly, ds); if (_indexAssemblies != null) { foreach (var indexAssembly in _indexAssemblies) { IndexCreation.CreateIndexes(indexAssembly, ds); } } //global::Raven.Client.Indexes.IndexCreation.CreateIndexes(typeof(RegionTrajectoryIndex).Assembly, ds); return(ds); }
private static void TryCreatingIndexesOrRedirectToErrorPage(Assembly[] indexAssemblies, string errorUrl) { try { foreach (var assembly in indexAssemblies) { IndexCreation.CreateIndexes(assembly, DocumentStore); } } catch (WebException e) { var socketException = e.InnerException as SocketException; if (socketException == null) { throw; } switch (socketException.SocketErrorCode) { case SocketError.AddressNotAvailable: case SocketError.NetworkDown: case SocketError.NetworkUnreachable: case SocketError.ConnectionAborted: case SocketError.ConnectionReset: case SocketError.TimedOut: case SocketError.ConnectionRefused: case SocketError.HostDown: case SocketError.HostUnreachable: case SocketError.HostNotFound: HttpContext.Current.Response.Redirect(errorUrl); break; default: throw; } } }
public void QueryMapReduceStaticIndex() { using (var documentStore = NewDocumentStore()) { documentStore.ConfigureForNodaTime(); using (var session = documentStore.OpenSession()) { var spotLine = new LearningContractSpotLine { Month = new LocalDate(2015, 02, 01), Contract = new LearningContract { Code = "11223344", Id = "contracts/12345" } }; session.Store(spotLine); session.SaveChanges(); } // have to create the index in the embedded test database per test run... IndexCreation.CreateIndexes(typeof(SpotLines_LineCountByMonth).Assembly, documentStore); using (var session = documentStore.OpenSession()) { var monthToQuery = new LocalDate(2015, 02, 01); RavenQueryStatistics statistics; var linesForMonth = session.Query <SpotLines_LineCountByMonth.ReduceResult, SpotLines_LineCountByMonth>() .Statistics(out statistics) .Customize(q => q.WaitForNonStaleResults(TimeSpan.FromSeconds(5))) .FirstOrDefault(c => c.Month == monthToQuery); Assert.Equal("SpotLines/LineCountByMonth", statistics.IndexName); Assert.Equal(1, linesForMonth.Count); } } }
private static StreamReader _sr; // Reads text back from CMD.exe private static IDocumentStore RamDocumentStore(bool injectData = true) { var documentStore = new DocumentStore { Url = "http://localhost:8080/" }; documentStore.Conventions.FindIdentityProperty = prop => prop.Name == "Id"; documentStore.Initialize(); if (injectData) { using (var documentSession = documentStore.OpenSession()) { // if we have no roles, system is not configured, so run system setup var roles = documentSession.Query <Role>().ToList(); if (roles.Count == 0) { var systemStateManager = new SystemStateManager(documentSession); var setupSystemDataCommandHander = new SetupSystemDataCommandHandler( documentStore, documentSession, systemStateManager ); setupSystemDataCommandHander.Handle(new SetupSystemDataCommand()); documentSession.SaveChanges(); } } } IndexCreation.CreateIndexes(typeof(All_Groups).Assembly, documentStore); return(documentStore); }
public static void Initialize() { try { Store = new DocumentStore { Url = "http://localhost:8080", DefaultDatabase = "Mvc4Sample" }; SetupConventions(Store.Conventions); Store.Initialize(); var types = Assembly.GetCallingAssembly().GetTypes().Where(t => t.GetCustomAttributes(typeof(ExplicitIndexAttribute), true).Length == 0); IndexCreation.CreateIndexes(new CompositionContainer(new TypeCatalog(types)), Store); ConfigureVersioning(); } catch (Exception e) { if (RedirectToErrorPageIfRavenDbIsDown(e) == false) { throw; } } }
public CqrsDocumentStoreFactory( IAddDocumenStoreFromParameters storeAdder, IDocumentStoreFactory documentStoreFactory, ICqrsDocumentStoreFactoryInitializer initializer = null) { this.documentStoreFactory = documentStoreFactory; storeAdder.AddStore( new DocumentStoreParameters { DatabaseName = "EventStore", FindTypeTagName = type => typeof(AbstractEvent).Name, TransformTypeTagNameToDocumentKeyPrefix = s => null }); IndexCreation.CreateIndexes(typeof(AbstractEvent_EventSourcedIdAndVersion).Assembly, this.EventStore); storeAdder.AddStore(new DocumentStoreParameters { DatabaseName = "ReadModel", FindIdentityPropertyNameFromEntityName = n => n + "Id", }); storeAdder.AddStore(new DocumentStoreParameters { DatabaseName = "SagaStore", FindIdentityPropertyNameFromEntityName = n => "CorrelationId" }); if (initializer == null) { return; } initializer.SetDocumentStoreFactory(this); initializer.Initialize(); }
public static IDocumentStore CreateNewDocumentStoreInitializeAndCreateUtilIndexes(string connectionStringName) { var documentStore = new DocumentStore { ConnectionStringName = connectionStringName /*"ToileDeFond.Tests"*//*, * Conventions = * { * JsonContractResolver = new DefaultContractResolver(shareCache: true) * { * DefaultMembersSearchFlags = BindingFlags.NonPublic | BindingFlags.Instance * }, * CustomizeJsonSerializer = serializer => serializer.PreserveReferencesHandling = PreserveReferencesHandling.Objects * }*/ //, //Conventions = // { // CustomizeJsonSerializer = serializer => // { // serializer.Converters.Add(new ContentJsonConverter(() => doc)); // serializer.Converters.Add(new ModuleJsonConverter()); // } // } , Conventions = { CustomizeJsonSerializer = serializer => { serializer.DateTimeZoneHandling = DateTimeZoneHandling.Utc; } } }; documentStore.Initialize(); IndexCreation.CreateIndexes(typeof(AllDocumentsById).Assembly, documentStore); return(documentStore); }
private static IDocumentStore SetupStore() { var store = new DocumentStore { Database = Database, Urls = Urls }; if (!string.IsNullOrEmpty(Thumbprint)) { using var certificateStore = new X509Store(StoreName.My, StoreLocation.CurrentUser); certificateStore.Open(OpenFlags.ReadOnly); var collection = certificateStore.Certificates.Find(X509FindType.FindByThumbprint, Thumbprint, false); var certificate = collection.OfType <X509Certificate2>().FirstOrDefault(); store.Certificate = certificate; } store.Conventions.IdentityPartsSeparator = "-"; store.Initialize(); IndexCreation.CreateIndexes(typeof(EverythingIndex).Assembly, store); return(store); }
public ActionResult SyncIndexes() { Server.ScriptTimeout = 7200; //timeout in 2 hours var masterDocumentStore = _storeFactory.Create(RavenInstance.Master()); IndexCreation.CreateIndexes(new CompositionContainer( new AssemblyCatalog(typeof(Issues).Assembly), new ExportProvider[0]), masterDocumentStore.DatabaseCommands.ForDatabase(CoreConstants.ErrorditeMasterDatabaseName), masterDocumentStore.Conventions); foreach (var organisation in Core.Session.MasterRaven.Query <Organisation>().GetAllItemsAsList(100)) { organisation.RavenInstance = Core.Session.MasterRaven.Load <RavenInstance>(organisation.RavenInstanceId); using (_session.SwitchOrg(organisation)) { _session.BootstrapOrganisation(organisation); } } ConfirmationNotification("All indexes for all organisations have been updated"); return(RedirectToAction("index")); }