public SparqlResultModel(string storeName, IBrightstarService service, SparqlRequestObject sparqlRequest, SparqlResultsFormat resultsFormat)
 {
     _storeName = storeName;
     _sparqlRequest = sparqlRequest;
     _service = service;
     ResultsFormat = resultsFormat;
 }

        public SparqlModule(IBrightstarService brightstarService, AbstractStorePermissionsProvider permissionsProvider)
        {
            this.RequiresBrightstarStorePermission(permissionsProvider, get:StorePermissions.Read, post:StorePermissions.Read);
            _brightstar = brightstarService;

            Get["/{storeName}/sparql"] = parameters =>
                {
                    try
                    {
                        var requestObject = BindSparqlRequestObject();
                        return ProcessQuery(parameters["storeName"], requestObject);
                    }
                    catch (RdfParseException)
                    {
                        return HttpStatusCode.BadRequest;
                    }
                };
            Post["/{storeName}/sparql"] = parameters =>
                {
                    try
                    {
                        var requestObject = BindSparqlRequestObject();
                        return ProcessQuery(parameters["storeName"], requestObject);
                    }
                    catch (RdfParseException)
                    {
                        return HttpStatusCode.BadRequest;
                    }
                };
            Get["/{storeName}/commits/{commitId}/sparql"] = ProcessCommitPointQuery;
            Post["/{storeName}/commits/{commitId}/sparql"] = ProcessCommitPointQuery;
        }

 /// <summary>
 /// Creates a new bootstrapper that denies all anonymous access to the specified Brightstar service
 /// but grants all authenticated users full access to the service and all of its stores.
 /// </summary>
 /// <param name="brightstarService"></param>
 public BrightstarBootstrapper(IBrightstarService brightstarService)
     : this(
         brightstarService, 
     new FallbackStorePermissionsProvider(StorePermissions.All),
     new FallbackSystemPermissionsProvider(SystemPermissions.All))
 {
 }

        public TransactionsModule(IBrightstarService brightstarService, AbstractStorePermissionsProvider storePermissionsProvider)
        {
            this.RequiresBrightstarStorePermission(storePermissionsProvider, get:StorePermissions.ViewHistory);

            Get["/{storeName}/transactions"] = parameters =>
                {
                    var transactionsRequest = this.Bind<TransactionsRequestObject>();
                    ViewBag.Title = transactionsRequest.StoreName + " - Transactions";
                    if (transactionsRequest.Take <= 0) transactionsRequest.Take = DefaultPageSize;
                    var transactions = brightstarService.GetTransactions(transactionsRequest.StoreName,
                                                                                 transactionsRequest.Skip,
                                                                                 transactionsRequest.Take + 1);
                    return Negotiate.WithPagedList(transactionsRequest,
                                                   transactions.Select(MakeResponseObject),
                                                   transactionsRequest.Skip, transactionsRequest.Take, DefaultPageSize,
                                                   "transactions");
                };

            Get["/{storeName}/transactions/byjob/{jobId}"] = parameters =>
                {
                    Guid jobId;
                    if (!Guid.TryParse(parameters["jobId"], out jobId))
                    {
                        return HttpStatusCode.NotFound;
                    }
                    var storeName = parameters["storeName"];
                    ViewBag.Title = storeName + " - Transaction - Job " + jobId;
                    var txn = brightstarService.GetTransaction(parameters["storeName"], jobId);
                    return txn == null ? HttpStatusCode.NotFound : MakeResponseObject(txn);
                };
        }

 public static void AssertTriplePatternInGraph(IBrightstarService client, string storeName, string triplePattern,
                               string graphUri)
 {
     var sparql = "ASK { GRAPH <" + graphUri + "> {" + triplePattern + "}}";
     var resultsDoc = XDocument.Load(client.ExecuteQuery(storeName, sparql));
     Assert.IsTrue(resultsDoc.SparqlBooleanResult());
 }

        public StoreModule(IBrightstarService brightstarService, AbstractStorePermissionsProvider storePermissionsProvider)
        {
            this.RequiresBrightstarStorePermission(storePermissionsProvider, get:StorePermissions.Read, delete:StorePermissions.Admin);

            Get["/{storeName}"] = parameters =>
            {
                var storeName = parameters["storeName"];
                ViewBag.Title = storeName;

                if (!brightstarService.DoesStoreExist(storeName)) return HttpStatusCode.NotFound;
                if (Request.Method.ToUpperInvariant() == "HEAD")
                {
                    IEnumerable < ICommitPointInfo > commitPoints = brightstarService.GetCommitPoints(storeName, 0, 1);
                    var commit = commitPoints.First();
                    return
                        Negotiate.WithHeader("Last-Modified", commit.CommitTime.ToUniversalTime().ToString("r"))
                            .WithStatusCode(HttpStatusCode.OK)
                            .WithModel(new StoreResponseModel(parameters["storeName"]));
                }
                return new StoreResponseModel(parameters["storeName"]);
            };

            Delete["/{storeName}"] = parameters =>
                {
                    var storeName = parameters["storeName"];
                    ViewBag.Title = "Deleted - " + storeName;
                    if (brightstarService.DoesStoreExist(storeName))
                    {
                        brightstarService.DeleteStore(storeName);
                    }
                    return Negotiate.WithMediaRangeModel(new MediaRange("text/html"), 
                                                         new StoreDeletedModel {StoreName = storeName});
                };
        }

 public static void AssertTriplePatternNotInDefaultGraph(IBrightstarService client, string storeName,
                                                       string triplePattern)
 {
     var sparql = "ASK {{" + triplePattern + "}}";
     var resultsDoc = XDocument.Load(client.ExecuteQuery(storeName, sparql));
     Assert.IsFalse(resultsDoc.SparqlBooleanResult());
 }

        public ServiceHost CreateServiceHost(IBrightstarService service, EventHandler onCloseEventHandler)
        {
            var httpPort = Configuration.HttPort;
            var tcpPort = Configuration.TcpPort;
            var pipeName = Configuration.NamedPipeName;

            var serviceHost = new ServiceHost(service, new[] {   new Uri(string.Format("http://localhost:{0}/brightstar", httpPort)) , 
                                                                                 new Uri(string.Format("net.tcp://localhost:{0}/brightstar", tcpPort)),
                                                                                 new Uri(string.Format("net.pipe://localhost/{0}", pipeName)) });

            var basicHttpBinding = new BasicHttpContextBinding { TransferMode = TransferMode.StreamedResponse, MaxReceivedMessageSize = int.MaxValue, SendTimeout = TimeSpan.FromMinutes(30), ReaderQuotas = XmlDictionaryReaderQuotas.Max, Namespace = "http://www.networkedplanet.com/schemas/brightstar" };
            var netTcpContextBinding = new NetTcpContextBinding { TransferMode = TransferMode.StreamedResponse, MaxReceivedMessageSize = int.MaxValue, SendTimeout = TimeSpan.FromMinutes(30), ReaderQuotas = XmlDictionaryReaderQuotas.Max, Namespace = "http://www.networkedplanet.com/schemas/brightstar" };
            var netNamedPipeBinding = new NetNamedPipeBinding { TransferMode = TransferMode.StreamedResponse, MaxReceivedMessageSize = int.MaxValue, SendTimeout = TimeSpan.FromMinutes(30), ReaderQuotas = XmlDictionaryReaderQuotas.Max, Namespace = "http://www.networkedplanet.com/schemas/brightstar" };

            serviceHost.AddServiceEndpoint(typeof(IBrightstarService), basicHttpBinding, "");
            serviceHost.AddServiceEndpoint(typeof(IBrightstarService), netTcpContextBinding, "");
            serviceHost.AddServiceEndpoint(typeof(IBrightstarService), netNamedPipeBinding, "");

            var throttlingBehavior = new ServiceThrottlingBehavior { MaxConcurrentCalls = int.MaxValue };

            serviceHost.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true });
            serviceHost.Description.Behaviors.Add(throttlingBehavior);

            serviceHost.Closed += onCloseEventHandler;

            return serviceHost;
        }

 public SparqlQueryProcessingModel(string storeName, IBrightstarService service, SparqlRequestObject sparqlRequest)
 {
     _storeName = storeName;
     _service = service;
     _sparqlRequest = sparqlRequest;
     ResultModel = sparqlRequest.Query == null ? SerializableModel.None : SparqlQueryHelper.GetResultModel(sparqlRequest.Query);
 }

 public SparqlQueryProcessingModel(string storeName, ulong commitId, IBrightstarService service,
                                   SparqlRequestObject sparqlRequest)
 {
     _storeName = storeName;
     _commitId = commitId;
     _service = service;
     _sparqlRequest = sparqlRequest;
 }

 public FakeNancyBootstrapper(IBrightstarService brightstarService,
                              AbstractStorePermissionsProvider storePermissionsProvider,
     AbstractSystemPermissionsProvider systemPermissionsProvider)
 {
     _brightstarService = brightstarService;
     _storePermissionsProvider = storePermissionsProvider;
     _systemPermissionsProvider = systemPermissionsProvider;
 }

 public static void AssertJobCompletesSuccessfully(IBrightstarService client, string storeName, IJobInfo job)
 {
     while (!job.JobCompletedOk && !job.JobCompletedWithErrors)
     {
         Task.Delay(10).Wait();
         job = client.GetJobInfo(storeName, job.JobId);
     }
     Assert.IsTrue(job.JobCompletedOk, "Expected job to complete successfully, but it failed with message '{0}' : {1}", job.StatusMessage, job.ExceptionInfo);
 }

 /// <summary>
 /// Creates a new bootstrapper that denies all anonymous access to the specified Brightstar service
 /// but grants all authenticated users full access to the service and all of its stores.
 /// </summary>
 /// <param name="brightstarService"></param>
 /// <param name="authenticationProviders">An enumeration of the authentication providers to be used by the service</param>
 public BrightstarBootstrapper(IBrightstarService brightstarService,
                               IEnumerable<IAuthenticationProvider> authenticationProviders)
     : this(
         brightstarService,
         authenticationProviders,
         new FallbackStorePermissionsProvider(StorePermissions.All),
         new FallbackSystemPermissionsProvider(SystemPermissions.All))
 {
 }

 protected void AssertJobSuccessful(IBrightstarService client,string storeName, IJobInfo job)
 {
     while (!(job.JobCompletedOk || job.JobCompletedWithErrors))
     {
         Task.Delay(3).Wait();
         job = client.GetJobInfo(storeName, job.JobId);
     }
     Assert.IsTrue(job.JobCompletedOk, "Job failed with message: {0} : {1}", job.StatusMessage, job.ExceptionInfo);
 }

 public LatestStatisticsModule(IBrightstarService brightstarService, AbstractStorePermissionsProvider storePermissionsProvider)
 {
     this.RequiresBrightstarStorePermission(storePermissionsProvider, get:StorePermissions.Read);
     Get["/{storeName}/statistics/latest"] = parameters =>
         {
             var latest = brightstarService.GetStatistics(parameters["storeName"]);
             if (latest == null) return HttpStatusCode.NotFound;
             return MakeResponseModel(latest);
         };
 }

 public SparqlResultModel(string storeName, ulong commitId, IBrightstarService service,
                          SparqlRequestObject sparqlRequest, SparqlResultsFormat resultsFormat, RdfFormat graphFormat)
 {
     _storeName = storeName;
     _commitId = commitId;
     _sparqlRequest = sparqlRequest;
     _service = service;
     ResultsFormat = resultsFormat;
     GraphFormat = graphFormat;
 }

        public StoresModule(IBrightstarService brightstarService, AbstractSystemPermissionsProvider systemPermissionsProvider)
        {
            this.RequiresBrightstarSystemPermission(systemPermissionsProvider, get:SystemPermissions.ListStores, post:SystemPermissions.CreateStore);

            Get["/"] = parameters =>
            {
                ViewBag.Title = "Stores";
                var stores = brightstarService.ListStores();
                return
                    Negotiate.WithModel(new StoresResponseModel
                        {
                            Stores = stores.ToList()
                        });
                };

            Post["/"] = parameters =>
                {
                    ViewBag.Title = "Stores";
                    var request = this.Bind<CreateStoreRequestObject>();
                    if (request == null || String.IsNullOrEmpty(request.StoreName))
                    {
                        return HttpStatusCode.BadRequest;
                    }

                    // Return 409 Conflict if attempt to create a store with a name that is currently in use
                    if (brightstarService.DoesStoreExist(request.StoreName))
                    {
                        return HttpStatusCode.Conflict;
                    }

                    // Attempt to create the store
                    try
                    {
                        PersistenceType? storePersistenceType = request.GetBrightstarPersistenceType();
                        if (storePersistenceType.HasValue)
                        {
                            brightstarService.CreateStore(request.StoreName, storePersistenceType.Value);
                        }
                        else
                        {
                            brightstarService.CreateStore(request.StoreName);
                        }
                    }
                    catch (ArgumentException)
                    {
                        return HttpStatusCode.BadRequest;   
                    }
                    return
                        Negotiate.WithModel(new StoreResponseModel(request.StoreName))
                                 .WithStatusCode(HttpStatusCode.Created);
                };
        }

        public CommitPointsModule(IBrightstarService brightstarService, AbstractStorePermissionsProvider permissionsProvider)
        {
            this.RequiresBrightstarStorePermission(permissionsProvider, get:StorePermissions.ViewHistory, post:StorePermissions.Admin);

            Get["/{storeName}/commits"] = parameters =>
                {
                    int skip = Request.Query["skip"].TryParse<int>(0);
                    int take = Request.Query["take"].TryParse<int>(DefaultPageSize);
                    DateTime timestamp = Request.Query["timestamp"].TryParse<DateTime>();
                    DateTime earliest = Request.Query["earliest"].TryParse<DateTime>();
                    DateTime latest = Request.Query["latest"].TryParse<DateTime>();

                    var request = this.Bind<CommitPointsRequestModel>();
                    ViewBag.Title = request.StoreName + " - Commit History";
                    
                    if (timestamp != default(DateTime))
                    {
                        // Request for a single commit point
                        var commitPoint = brightstarService.GetCommitPoint(parameters["storeName"], timestamp);
                        return commitPoint == null ? HttpStatusCode.NotFound : MakeResponseObject(commitPoint);
                    }
                    if (earliest != default(DateTime) && latest != default(DateTime))
                    {
                        IEnumerable<ICommitPointInfo> results =
                            brightstarService.GetCommitPoints(parameters["storeName"], latest, earliest, skip, take + 1);
                        var resourceUri = String.Format("commits?latest={0}&earliest={1}", latest.ToString("s"), earliest.ToString("s"));
                        return Negotiate.WithPagedList(request, results.Select(MakeResponseObject), skip, take, DefaultPageSize, resourceUri);
                    }
                    IEnumerable<ICommitPointInfo> commitPointInfos = brightstarService.GetCommitPoints(parameters["storeName"], skip, take + 1);
                    return Negotiate.WithPagedList(request, commitPointInfos.Select(MakeResponseObject), skip, take, DefaultPageSize, "commits");
                };

            Post["/{storeName}/commits"] = parameters =>
                {
                    var commitPoint = this.Bind<CommitPointResponseModel>();
                    if (commitPoint == null ||
                        String.IsNullOrEmpty(commitPoint.StoreName) ||
                        !commitPoint.StoreName.Equals(parameters["storeName"]))
                    {
                        return HttpStatusCode.BadRequest;
                    }

                    var commitPointInfo = brightstarService.GetCommitPoint(parameters["storeName"], commitPoint.Id);
                    if (commitPointInfo == null) return HttpStatusCode.BadRequest;

                    brightstarService.RevertToCommitPoint(parameters["storeName"], commitPointInfo);
                    return HttpStatusCode.OK;
                };
        }

 public static IJobInfo WaitForJob(IJobInfo job, IBrightstarService client, string storeName)
 {
     var cycleCount = 0;
     while (!job.JobCompletedOk && !job.JobCompletedWithErrors && cycleCount < 100)
     {
         Thread.Sleep(500);
         cycleCount++;
         job = client.GetJobInfo(storeName, job.JobId);
     }
     if (!job.JobCompletedOk && !job.JobCompletedWithErrors)
     {
         Assert.Fail("Job did not complete in time.");
     }
     return job;
 }

 static bool RunCompressJob(IBrightstarService client, string storeName, out string finalMessage)
 {
     var compressJob = client.ConsolidateStore(storeName);
     while (!(compressJob.JobCompletedOk || compressJob.JobCompletedWithErrors))
     {
         System.Threading.Thread.Sleep(1000);
         compressJob = client.GetJobInfo(storeName, compressJob.JobId);
     }
     finalMessage = compressJob.StatusMessage;
     if (compressJob.ExceptionInfo != null)
     {
         finalMessage += " Exception Detail:" + compressJob.ExceptionInfo;
     }
     return compressJob.JobCompletedOk;
 }