private static void SetupFacets( String id, IDocumentStore store )
        {
            var facet = new FacetSetup()
            {
                Id = id,
                Facets =
                {
                    new Facet<Orders.Product>()
                    {
                        Name = p=>p.Supplier
                    },
                    new Facet<Orders.Product>()
                    {
                        Name = p=>p.PricePerUser,
                        Ranges =
                        {
                            p=>p.PricePerUser <= 50,
                            p=>p.PricePerUser > 50 && p.PricePerUser <= 100,
                            p=>p.PricePerUser > 100 && p.PricePerUser <= 200,
                            p=>p.PricePerUser > 200,
                        }
                    },
                }
            };

            using ( var session = store.OpenSession() )
            {
                session.Store( facet );
                session.SaveChanges();
            }
        }

        /// <summary>
        /// Registers the document store.
        /// </summary>
        /// <param name="documentStore">The document store.</param>
        public static void RegisterDocumentStore(IDocumentStore documentStore)
        {
            SessionFactory.DocumentStoreInstance = documentStore;

            documentStore.Conventions.CustomizeJsonSerializer += json => json.ReferenceLoopHandling = ReferenceLoopHandling.Serialize;

            // register custom contract resolver to handle relations
            documentStore.Conventions.JsonContractResolver = new RelationContractResolver(
                (DefaultRavenContractResolver)documentStore.Conventions.JsonContractResolver,
                documentStore.Conventions,
                ListOfModelTypes());

            var componentInstances = IoC.ResolveAllInstances<IComponentDbInit>().ToArray();

            // customize document store
            foreach (var componentDbInit in componentInstances)
            {
                componentDbInit.CustomizeDocumentStore(documentStore);
            }

            // register indexes
            foreach (var componentDbInit in componentInstances)
            {
                componentDbInit.RegisterIndexes(documentStore);
            }
        }

		private void ExecuteTest(IDocumentStore store)
		{
			CreateIndexAndSampleData(store);

			// there are 10K documents, each combination of "Lorem" and "Nullam" has 100 matching documents.
			// Suspect that this may be failing because each individual slice (Lorem: L and Nullam: N)
			// has 1000 documents, which is greater than default page size of 128.
			foreach (string L in Lorem)
			{
				foreach (string N in Nullam)
				{
					using (var session = store.OpenSession())
					{
						var result = session.Query<TestAttributes>("TestAttributesByAttributes")
									.Where(o => o.Attributes.Any(t => t.Key == "Lorem" && t.Value == L))
									.OrderBy(o => o.Id)
									.Intersect()
									.Where(o => o.Attributes.Any(t => t.Key == "Nullam" && t.Value == N))
									.ToList();

						Assert.Equal(100, result.Count);
					}
				}
			}
		}

		/// <summary>
		/// Initializes the RavenProfiler for MVC.
		/// IMPORTANT! This method may only be called from the Application_Start method, otherwise
		/// it might lead to problems, since it modify the Routes table.
		/// </summary>
		public static void InitializeFor(IDocumentStore store, params string[] fieldsToFilter)
		{
			var existing = RouteTable.Routes
				.Select(x =>
				{
					var route = x as Route;
					if (route == null)
						return null;
					return route.RouteHandler;
				})
				.OfType<RavenProfilingHandler>()
				.FirstOrDefault();

			if (existing != null)
			{
				existing.AddStore(store);
				return;
			}
			store.Conventions.DisableProfiling = false;

			((DocumentStore)store).InitializeProfiling();
			
			ProfilingInformation.OnContextCreated += ProfilingInformationOnOnContextCreated;

			var ravenProfilingHandler = new RavenProfilingHandler(new HashSet<string>(fieldsToFilter ?? Enumerable.Empty<string>()));
			ravenProfilingHandler.AddStore(store);

			RouteTable.Routes.Insert(0, new Route("ravendb/profiling", new RouteValueDictionary(new { controller = "RavenProfilingHandler", action = "ProcessRequest" }), ravenProfilingHandler));
			GlobalFilters.Filters.Add(new RecordCurrentControllerContextFilter(), -100);
		}

 public static void CreateOrUpdateUserAuthIndex(IDocumentStore store)
 {
     // put this index into the ravendb database
     new ServiceStack_UserAuth_ByUserNameOrEmail().Execute(store);
     new ServiceStack_UserAuth_ByOAuthProvider().Execute(store);
     _isInitialized = true;
 }

 public static IEnumerable<Func<CancellationToken, Task>> Tasks(ICommandSender service, IDocumentStore docs,
     bool isTest)
 {
     var flow = new DomainSender(service);
     // more tasks go here
     yield break;
 }

 private static ServerSettings GetServerSettings(IDocumentStore documentStore)
 {
     using (var session = documentStore.OpenSession())
     {
         return session.Load<ServerSettings>("ServerSettings/1");
     }
 }

		/// <summary>
		/// Initializes a new instance of the <see cref="HiLoKeyGenerator"/> class.
		/// </summary>
		/// <param name="documentStore">The document store.</param>
		/// <param name="tag">The tag.</param>
		/// <param name="capacity">The capacity.</param>
		public HiLoKeyGenerator(IDocumentStore documentStore, string tag, long capacity)
		{
			this.documentStore = documentStore;
			this.tag = tag;
			this.capacity = capacity;
			current = 0;
		}

		public static void WaitForIndexing(IDocumentStore store)
		{
			while (store.DatabaseCommands.GetStatistics().StaleIndexes.Length > 0)
			{
				Thread.Sleep(100);
			}
		}

        public static void CreateInitialData(IDocumentStore store, string databaseName)
        {
            store.DatabaseCommands.GlobalAdmin.EnsureDatabaseExists(databaseName);
            using (var bulkInsert = store.BulkInsert())
            {
                foreach (var category in DataFactory.Categories.GenerateMany(Constants.NumOfCategories))
                    bulkInsert.Store(category);

                foreach (var company in DataFactory.Companies.GenerateMany(Constants.NumOfCompanies))
                    bulkInsert.Store(company);

                foreach (var employee in DataFactory.Employees.GenerateMany(Constants.NumOfEmployees))
                    bulkInsert.Store(employee);

                foreach (var order in DataFactory.Orders.GenerateMany(Constants.NumOfOrders))
                    bulkInsert.Store(order);

                foreach (var product in DataFactory.Products.GenerateMany(Constants.NumOfProducts))
                    bulkInsert.Store(product);

                foreach (var region in DataFactory.Regions.GenerateMany(Constants.NumOfRegions))
                    bulkInsert.Store(region);

                foreach (var shipper in DataFactory.Shippers.GenerateMany(Constants.NumOfShippers))
                    bulkInsert.Store(shipper);

                foreach (var supplier in DataFactory.Suppliers.GenerateMany(Constants.NumOfSuppliers))
                    bulkInsert.Store(supplier);
            }

            new OrdersByCompany().Execute(store);
            new OrdersTotals().Execute(store);
            new ProductSales().Execute(store);
            new OrderLines_ByProduct().Execute(store);
        }

 public static void ExecuteIndexes(IDocumentStore store)
 {
     new OrdersByCompany().Execute(store);
     new OrdersTotals().Execute(store);
     new ProductSales().Execute(store);
     new OrderLines_ByProduct().Execute(store);
 }

 //Change to allow for Multi- Tenancy cases
 //User has to call this method every time he creates a new tenant DB
 public static void CreateOrUpdateUserAuthIndex(IDocumentStore store,string databaseName)
 {
     // put this index into the ravendb database
     var catalog = new CompositionContainer(new AssemblyCatalog(typeof(ServiceStack_UserAuth_ByUserNameOrEmail).Assembly));
     IndexCreation.CreateIndexes(catalog, store.DatabaseCommands.ForDatabase(databaseName), store.Conventions);
     _isInitialized = true;
 }

 public static IDocumentStore Initialize()
 {
     instance = new EmbeddableDocumentStore { ConnectionStringName = "RavenDB" };
     instance.Conventions.IdentityPartsSeparator = "-";
     instance.Initialize();
     return instance;
 }

        public RavenDbSessionStore(CryptographyConfiguration cryptographyConfiguration, IDocumentStore documentStore)
            : base(cryptographyConfiguration)
        {
            Guard.NotNull(() => documentStore, documentStore);

            this.documentStore = documentStore;
        }

        public QuestionsController(IDocumentStore documentStore, IQuestionService questionService)
            : base(documentStore)
        {
            Condition.Requires(questionService).IsNotNull();

            _questionService = questionService;
        }

 private UserWithGuid[] GetUsers(IDocumentStore documentStore)
 {
     using (var session = documentStore.QuerySession())
     {
         return session.Query<UserWithGuid>().ToArray();
     }
 }

 private void LoadDocs(IDocumentStore store)
 {
     using (var session = store.OpenSession())
     {
         session.Load<Order>(orderIDs);
     }
 }

		private static void CreateSections(IDocumentStore store)
		{
			Console.WriteLine("Creating sections");
			using (IDocumentSession s = store.OpenSession())
			{
				var sections = new[]
					{
						new Section {Title = "Future Posts", ControllerName = "Section", ActionName = "FuturePosts"},
						new Section {Title = "Statistics", ControllerName = "Section", ActionName = "PostsStatistics"},
						new Section {Title = "Tags", ControllerName = "Section", ActionName = "TagsList"},
						new Section {Title = "Archive", ControllerName = "Section", ActionName = "ArchivesList"},
					};

				var i = 0;
				foreach (var section in sections)
				{
					section.Position = i;
					section.IsActive = true;
					s.Store(section);
					i++;
				}
				s.SaveChanges();
			}
			Console.WriteLine("Finish creating sections");
		}

	    private void DoTest(IDocumentStore store1, IDocumentStore store2)
	    {
	        using (var session = store1.OpenSession())
	        {
	            session.Store(new Company());
	            session.SaveChanges();
	        }

	        using (var session = store2.OpenSession())
	        {
	            session.Store(new Company());
	            session.SaveChanges();
	        }

	        store1.DatabaseCommands.Put("marker", null, new RavenJObject(), new RavenJObject());

	        TellFirstInstanceToReplicateToSecondInstance();

	        WaitForReplication(store2, "marker");

	        var conflictException = Assert.Throws<ConflictException>(() =>
	        {
	            using (var session = store2.OpenSession())
	            {
	                var loadStartingWith = session.Advanced.LoadStartingWith<Company>("companies/");
	            }
	        });

	        Assert.Equal("Conflict detected on companies/1, conflict must be resolved before the document will be accessible",
	                     conflictException.Message);
	    }

        public static void CreateSeedData(IDocumentStore documentStore)
        {
            Condition.Requires(documentStore).IsNotNull();

            using (IDocumentSession documentSession = documentStore.OpenSession())
            {
                // First, check to make sure we don't have any data.
                var user = documentSession.Load<User>(1);
                if (user != null)
                {
                    // ooOooo! we have a user, so it's assumed we actually have some seeded data.
                    return;
                }

                // We have no users, so it's assumed we therefore have no data at all.
                // So lets fake some up :)

                // Users.
                ICollection<User> users = FakeUsers.CreateFakeUsers(50);
                StoreFakeEntities(users, documentSession);

                // Questions.
                ICollection<Question> questions = FakeQuestions.CreateFakeQuestions(users.Select(x => x.Id).ToList());
                StoreFakeEntities(questions, documentSession);

                documentSession.SaveChanges();

                // Make sure all our indexes are not stale.
                documentStore.WaitForStaleIndexesToComplete();
            }
        }