public IEnumerable<Task> Initialize(IAsyncDocumentSession session)
		{
			// those are no longer needed, when we request the
			// Silverlight UI from the server, those indexes will 
			// be created automatically

			//yield return session.Advanced.AsyncDatabaseCommands
			//    .PutIndexAsync<RavenDocumentsByEntityName>(true);

			//yield return session.Advanced.AsyncDatabaseCommands
			//    .PutIndexAsync<RavenCollections>(true);

			SimpleLogger.Start("preloading collection templates");
			var templateProvider = IoC.Get<IDocumentTemplateProvider>();
			var collections = session.Advanced.AsyncDatabaseCommands.GetCollectionsAsync(0, 25);
			yield return collections;

			var preloading  = collections.Result
				.Select(x=>x.Name)
				.Union(Enumeration.All<BuiltinCollectionName>().Select(x => x.Value))
				.Select(templateProvider.GetTemplateFor);

			foreach (var task in preloading)
				yield return task;

			SimpleLogger.End("preloading collection templates");
		}

        internal static async Task<AuthorizationCode> FromDbFormat(StoredAuthorizationCode code, IAsyncDocumentSession s, IScopeStore scopeStore)
        {
            var result = new AuthorizationCode
            {
                CreationTime = code.CreationTime,
                IsOpenId = code.IsOpenId,
                RedirectUri = code.RedirectUri,
                WasConsentShown = code.WasConsentShown,
                Nonce = code.Nonce,
                Client = Data.StoredClient.FromDbFormat(await s.LoadAsync<Data.StoredClient>("clients/" + code.Client)),
                CodeChallenge = code.CodeChallenge,
                CodeChallengeMethod = code.CodeChallengeMethod,
                SessionId = code.SessionId,
                RequestedScopes = await scopeStore.FindScopesAsync(code.RequestedScopes)
            };

            var claimsPrinciple = new ClaimsPrincipal();
            foreach (var id in code.Subject)
            {
                claimsPrinciple.AddIdentity(Data.StoredIdentity.FromDbFormat(id));
            }
            result.Subject = claimsPrinciple;

            return result;
        }

		public DiscoveryModule(IAsyncDocumentSession session)
			: base("/api/discovery")
		{
			this.session = session;

			Get["/start"] = parameters =>
			{
				var discoveryClient = new ClusterDiscoveryClient(SenderId, "http://localhost:9020/api/discovery/notify");
				discoveryClient.PublishMyPresenceAsync();
				return "started";
			};

			Post["/notify", true] = async (parameters, ct) =>
			{
				var input = this.Bind<ServerRecord>("Id");

				var server = await session.Query<ServerRecord>().Where(s => s.Url == input.Url).FirstOrDefaultAsync() ?? new ServerRecord();
				this.BindTo(server, "Id");
				await session.StoreAsync(server);

				await HealthMonitorTask.FetchServerDatabases(server, session.Advanced.DocumentStore);

				return "notified";
			};
		}

 public BlogPostController(IMvcLogger logger, IAsyncDocumentSession documentSession, IConfigurationManager configManager, AkismetClient akismetClient, IMappingEngine mapper)
     : base(logger, documentSession)
 {
     _configManager = configManager;
     _akismetClient = akismetClient;
     _mapper = mapper;
 }

        public IQueryable<Record> AsyncQuery(IAsyncDocumentSession adb, RecordQueryInputModel input)
        {
            var query = adb.Query<RecordIndex.Result, RecordIndex>()
                .Statistics(out stats);

            return RecordQueryImpl(input, query);
        }

 public static ContextBag CreateContextWithAsyncSessionPresent(this RavenDBPersistenceTestBase testBase, out IAsyncDocumentSession session)
 {
     var context = new ContextBag();
     session = testBase.OpenAsyncSession();
     context.Set(session);
     return context;
 }

		public IEnumerable<Task> Initialize(IAsyncDocumentSession session)
		{
			yield return session.Advanced.AsyncDatabaseCommands
				.PutIndexAsync(@"Studio/DocumentCollections",
				               new IndexDefinition
				               	{
				               		Map =
				               			@"from doc in docs
let Name = doc[""@metadata""][""Raven-Entity-Name""]
where Name != null
select new { Name , Count = 1}
",
				               		Reduce =
				               			@"from result in results
group result by result.Name into g
select new { Name = g.Key, Count = g.Sum(x=>x.Count) }"
				               	}, true);


			// preload collection templates
			var templateProvider = IoC.Get<IDocumentTemplateProvider>();
			var collections = session.Advanced.AsyncDatabaseCommands.GetCollectionsAsync(0, 25);
			yield return collections;

			var preloading  = collections.Result
				.Select(x=>x.Name)
				.Union(Enumeration.All<BuiltinCollectionName>().Select(x => x.Value))
				.Select(templateProvider.GetTemplateFor);

			foreach (var task in preloading)
				yield return task;
		}

		public static async Task<AsyncServerClient> CreateAsyncServerClient(IAsyncDocumentSession session, ServerRecord server, ServerCredentials serverCredentials = null)
		{
			var documentStore = (DocumentStore)session.Advanced.DocumentStore;
			var replicationInformer = new ReplicationInformer(new DocumentConvention
			{
				FailoverBehavior = FailoverBehavior.FailImmediately
			});

			ICredentials credentials = null;
			if (serverCredentials != null)
			{
				credentials = serverCredentials.GetCredentials();
			}
			else if (server.CredentialsId != null)
			{
				serverCredentials = await session.LoadAsync<ServerCredentials>(server.CredentialsId);
				if (serverCredentials == null)
				{
					server.CredentialsId = null;
				}
				else
				{
					credentials = serverCredentials.GetCredentials();
				}
			}

			return new AsyncServerClient(server.Url, documentStore.Conventions, credentials,
										 documentStore.JsonRequestFactory, null, s => replicationInformer, null, new IDocumentConflictListener[0]);
		}

        protected static async Task SaveEntities(IEnumerable<IEntity> entities, IAsyncDocumentSession session)
        {
            foreach (var entity in entities)
            {
                await session.StoreAsync(entity);
            }

            await session.SaveChangesAsync();
        }

        public async Task DoStuff(EndpointConfiguration configuration, IAsyncDocumentSession someAsyncSession)
        {
            #region 3to4-ravensharedsession
            Func<IAsyncDocumentSession> sessionFactory = () => someAsyncSession;

            configuration.UsePersistence<RavenDBPersistence>()
                .UseSharedAsyncSession(sessionFactory);
            #endregion
        }

        void DoStuff(EndpointConfiguration endpointConfiguration, IAsyncDocumentSession someAsyncSession)
        {
            #region 3to4-ravensharedsession
            Func<IAsyncDocumentSession> sessionFactory = () => someAsyncSession;

            var persistence = endpointConfiguration.UsePersistence<RavenDBPersistence>();
            persistence.UseSharedAsyncSession(sessionFactory);
            #endregion
        }

 private async Task EnsureSubscriptionsExists(IAsyncDocumentSession session)
 {
     var subscription = await session.LoadAsync<Subscription>(Subscription.Id);
     if (subscription == null)
     {
         subscription = new Subscription();
         await session.StoreAsync(subscription);
         await session.SaveChangesAsync();
     }
 }

        private async Task<IEnumerable<Knock>> GetKnocksByFeedId(IAsyncDocumentSession session, string feedId)
        {
            if (session == null)
                throw new ArgumentNullException(nameof(session));

            if (String.IsNullOrWhiteSpace(feedId))
                throw new ArgumentNullException(nameof(feedId));

            return await session.Query<Knock, Knock_ByFeed>().Where(knock => knock.FeedId==feedId).ToListAsync();
        }

        public static void CreateCustomer(IAsyncDocumentSession session, string name, AddressOptions addressOptions)
        {
            var entity = new Customer { Name = name };

            if (addressOptions == AddressOptions.Home || addressOptions == AddressOptions.HomeAndBusines)
                entity.Addresses.Add(CreateAddress(AddressOptions.Home));

            if (addressOptions == AddressOptions.Business || addressOptions == AddressOptions.HomeAndBusines)
                entity.Addresses.Add(CreateAddress(AddressOptions.Business));

            session.Store(entity);
        }

        static Task<IList<string>> FirstQuery(IAsyncDocumentSession session)
        {
            var now = DateTime.UtcNow;

            RavenQueryStatistics stats;
            return session.Query<Logfile>()
                .Statistics(out stats)
                .Where(x => x.UploadDate >= now.AddMonths(-1))
                .Select(x => x.Owner)
                .Distinct()
                .Take(1024) // see 
                .ToListAsync();
        }

        private static async Task CreateUsersAsync(IAsyncDocumentSession session)
        {
            var user1 = new User {Name = "Jane"};
            user1.OfficesIds.Add("office/1");
            user1.OfficesIds.Add("office/2");

            var user2 = new User {Name = "Bill"};
            user2.OfficesIds.Add("office/1");
            user2.OfficesIds.Add("office/3");

            await session.StoreAsync(user1);
            await session.StoreAsync(user2);
        }

        /// <summary>
        /// Projects the specified message asynchronously.
        /// </summary>
        /// <param name="session">The Raven session used during projection.</param>
        /// <param name="message">The message to project.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        ///     A <see cref="Task" />.
        /// </returns>
        /// <exception cref="System.ArgumentNullException">Thrown when <paramref name="session"/> or <paramref name="message"/> is <c>null</c>.</exception>
        public async Task ProjectAsync(IAsyncDocumentSession session, object message, CancellationToken cancellationToken)
        {
            if (session == null) throw new ArgumentNullException("session");
            if (message == null) throw new ArgumentNullException("message");

            RavenProjectionHandler[] handlers;
            if (_handlers.TryGetValue(message.GetType(), out handlers))
            {
                foreach (var handler in handlers)
                {
                    await handler.Handler(session, message, cancellationToken);
                }
            }
        }

        protected static AccountsController GetAccountsController(IAsyncDocumentSession session)
        {
            var appUserManager = GetApplicationUserManager(session);
            var appRoleManager = GetApplicationRoleManager(session);
            var mockUrlHelper = new Mock<UrlHelper>();
            mockUrlHelper.Setup(c => c.Link(It.IsAny<string>(), It.IsAny<object>())).Returns("http://location");

            var controller = new AccountsController(appUserManager,appRoleManager)
            {
                Url = mockUrlHelper.Object,
                Request = new HttpRequestMessage(),
                Configuration = new HttpConfiguration()
            };

            controller.Configuration.Routes.MapHttpRoute("GetUserById", "api/{controller}/{id}", new {id = RouteParameter.Optional});

            return controller;
        }

        public async Task<ActionResult> Index(IAsyncDocumentSession asyncSession)
        {
            // Remove when MVC 4 is released (http://forums.asp.net/p/1778103/4880898.aspx/1?Re+Using+an+Async+Action+to+Run+Synchronous+Code)
            await Task.Yield();

            var mike = (await asyncSession.Query<User>().Take(1).ToListAsync()).FirstOrDefault();
            if (mike == null)
            {
                mike = new User {FirstName = "Mike", LastName = "Noonan"};
                asyncSession.Store(mike);
                await asyncSession.SaveChangesAsync();
            }
            if (mike.F1AccessToken == null || mike.PCOAccessToken == null)
            {
                return RedirectToAction("Authenticate", "F1Auth");
            }

            return View();
        }

        private static void CreateDefaultData(IAsyncDocumentSession session)
        {
            var role = new ApplicationRole("Admin");
            session.StoreAsync(role);

            var hasher = new PasswordHasher();
            var passwordHash = hasher.HashPassword("admin");
            var superUser = new ApplicationUser("SuperAdmin")
            {
                Email = "[email protected]",
                FirstName = "Super",
                LastName = "Admin",
                UserName = "superadmin",
                PasswordHash = passwordHash,
                EmailConfirmed = true,
                Roles = {"Admin"}
            };

            session.StoreAsync(superUser);

            session.SaveChangesAsync();
        }