public byte[] AsBytes() { var memoryStream = new MemoryStream(); JsonExtensions.CreateDefaultJsonSerializer().Serialize(new BsonWriter(memoryStream), this); return(memoryStream.ToArray()); }
public async Task <SynchronizationConfirmation[]> GetConfirmationForFilesAsync(IEnumerable <Tuple <string, Etag> > sentFiles) { var requestUriString = string.Format("{0}/synchronization/Confirm", baseUrl); using (var request = RequestFactory.CreateHttpJsonRequest(new CreateHttpJsonRequestParams(this, requestUriString, HttpMethods.Post, Credentials, Conventions)).AddOperationHeaders(OperationsHeaders)) { try { using (var stream = new MemoryStream()) { var sb = new StringBuilder(); var jw = new JsonTextWriter(new StringWriter(sb)); JsonExtensions.CreateDefaultJsonSerializer().Serialize(jw, sentFiles); var bytes = Encoding.UTF8.GetBytes(sb.ToString()); await stream.WriteAsync(bytes, 0, bytes.Length).ConfigureAwait(false); stream.Position = 0; await request.WriteAsync(stream).ConfigureAwait(false); var response = (RavenJArray)await request.ReadResponseJsonAsync().ConfigureAwait(false); return(response.JsonDeserialization <SynchronizationConfirmation>()); } } catch (Exception e) { throw e.SimplifyException(); } } }
public MapReduceIndex(Directory directory, int id, IndexDefinition indexDefinition, AbstractViewGenerator viewGenerator, WorkContext context) : base(directory, id, indexDefinition, viewGenerator, context) { jsonSerializer = JsonExtensions.CreateDefaultJsonSerializer(); jsonSerializer.Converters = MapReduceConverters; }
private Field CreateBinaryFieldWithCaching(string name, byte[] value, Field.Store store, Field.Index index, Field.TermVector termVector) { if (value.Length > 1024) { throw new ArgumentException("Binary values must be smaller than 1Kb"); } var cacheKey = new FieldCacheKey(name, null, store, termVector, multipleItemsSameFieldCount.ToArray()); Field field; var stringWriter = new StringWriter(); JsonExtensions.CreateDefaultJsonSerializer().Serialize(stringWriter, value); var sb = stringWriter.GetStringBuilder(); sb.Remove(0, 1); // remove prefix " sb.Remove(sb.Length - 1, 1); // remove postfix " var val = sb.ToString(); if (fieldsCache.TryGetValue(cacheKey, out field) == false) { fieldsCache[cacheKey] = field = new Field(name, val, store, index, termVector); } field.SetValue(val); field.Boost = 1; field.OmitNorms = true; return(field); }
private async Task ImportData(SmugglerImportOptions <FilesConnectionStringOptions> importOptions, string filename) { var sw = Stopwatch.StartNew(); var directory = Path.GetDirectoryName(filename); var serializer = JsonExtensions.CreateDefaultJsonSerializer(); // We open the zip file. using (var archive = new ZipArchive(File.OpenRead(filename), ZipArchiveMode.Read)) { var filesLookup = archive.Entries.ToDictionary(x => x.FullName); var metadataEntry = filesLookup[".metadata"]; using (var streamReader = new StreamReader(metadataEntry.Open())) { foreach (var json in streamReader.EnumerateJsonObjects()) { // For each entry in the metadata file. var container = serializer.Deserialize <FileContainer>(new StringReader(json)); var entry = filesLookup[container.Key]; using (var dataStream = entry.Open()) { var header = new FileHeader(container.Key, container.Metadata); await Operations.PutFiles(header, dataStream, entry.Length); } Options.CancelToken.Token.ThrowIfCancellationRequested(); } Options.CancelToken.Token.ThrowIfCancellationRequested(); } } sw.Stop(); }
private IEnumerable <IEnumerable <TimeSeriesAppend> > YieldChangeBatches(Stream requestStream, CancellationTimeout timeout, Action <int> changeTimeSeriesFunc) { var serializer = JsonExtensions.CreateDefaultJsonSerializer(); try { using (requestStream) { var binaryReader = new BinaryReader(requestStream); while (true) { timeout.ThrowIfCancellationRequested(); int batchSize; try { batchSize = binaryReader.ReadInt32(); } catch (EndOfStreamException) { break; } using (var stream = new PartialStream(requestStream, batchSize)) { yield return(YieldBatchItems(stream, serializer, timeout, changeTimeSeriesFunc)); } } } } finally { requestStream.Close(); } }
public void Execute(DocumentDatabase database) { if (string.IsNullOrEmpty(database.Name) == false) { return; // we don't care about tenant databases } if (string.Equals(database.Configuration.AuthenticationMode, "OAuth", StringComparison.InvariantCultureIgnoreCase) == false) { return; // we don't care if we aren't using oauth } var array = database.GetDocumentsWithIdStartingWith("Raven/Users/", 0, 1); if (array.Length > 0) { return; // there is already at least one user in there } var pwd = Guid.NewGuid().ToString(); if (database.Configuration.RunInMemory == false) { var authConfigPath = Path.Combine(Path.GetDirectoryName(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile), "authentication.config"); File.WriteAllText(authConfigPath, @"Since no users were found in the database, and the database authentication mode was set to OAuth, the following user was automatically created. Username: Admin Password: "******" You can use those credentials to login to RavenDB."); logger.Info(@"Since no users were found, and the database authentication mode was set to OAuth, a default user was generated name 'Admin'. Credentials for this user can be found in the following file: {0}", authConfigPath); } var ravenJTokenWriter = new RavenJTokenWriter(); JsonExtensions.CreateDefaultJsonSerializer().Serialize(ravenJTokenWriter, new AuthenticationUser { AllowedDatabases = new[] { "*" }, Name = "Admin", Admin = true }.SetPassword(pwd)); var userDoc = (RavenJObject)ravenJTokenWriter.Token; userDoc.Remove("Id"); database.Put("Raven/Users/Admin", null, userDoc, new RavenJObject { { Constants.RavenEntityName, "AuthenticationUsers" }, { Constants.RavenClrType, typeof(AuthenticationUser).FullName + ", " + typeof(AuthenticationUser).Assembly.GetName().Name } }, null); }
private static RavenJObject GetMapedData(object doc) { if (doc is IDynamicJsonObject) { return(((IDynamicJsonObject)doc).Inner); } return(RavenJObject.FromObject(doc, JsonExtensions.CreateDefaultJsonSerializer())); }
public static void SetAuthorizationFor(this IDocumentSession session, object entity, DocumentAuthorization documentAuthorization) { var metadata = session.Advanced.GetMetadataFor(entity); var jsonSerializer = JsonExtensions.CreateDefaultJsonSerializer(); jsonSerializer.ContractResolver = session.Advanced.DocumentStore.Conventions.JsonContractResolver; metadata[RavenDocumentAuthorization] = RavenJObject.FromObject(documentAuthorization, jsonSerializer); }
public void CanUseMultiQuery() { using (GetNewServer()) using (var docStore = new DocumentStore { Url = "http://localhost:8079" }.Initialize()) { using (var session = docStore.OpenSession()) { session.Store(new User { Name = "Ayende" }); session.Store(new User { Name = "Oren" }); session.SaveChanges(); } using (var session = docStore.OpenSession()) { session.Query <User>() .Customize(x => x.WaitForNonStaleResults()) .Where(u => u.Name == "Ayende") .ToArray(); } var request = (HttpWebRequest)WebRequest.Create("http://localhost:8079/multi_get"); request.Method = "POST"; using (var stream = request.GetRequestStream()) { var streamWriter = new StreamWriter(stream); JsonExtensions.CreateDefaultJsonSerializer().Serialize(streamWriter, new[] { new GetRequest { Url = "/indexes/dynamic/Users", Query = "query=Name:Ayende" }, new GetRequest { Url = "/indexes/dynamic/Users", Query = "query=Name:Oren" }, }); streamWriter.Flush(); stream.Flush(); } using (var resp = request.GetResponse()) using (var stream = resp.GetResponseStream()) { var result = new StreamReader(stream).ReadToEnd(); Assert.Contains("Ayende", result); Assert.Contains("Oren", result); } } }
private static string ToQueryString(RavenJObject metadata) { var serializer = JsonExtensions.CreateDefaultJsonSerializer(); var sb = new StringBuilder(); serializer.Serialize(new JsonTextWriter(new StringWriter(sb)), metadata); return(sb.ToString()); }
public override void Prepare(string id, Guid?resourceManagerId, byte[] recoveryInformation) { try { EsentTransactionContext context; if (transactionContexts.TryGetValue(id, out context) == false) { var myContext = CreateEsentTransactionContext(); try { context = transactionContexts.GetOrAdd(id, myContext); } finally { if (myContext != context) { myContext.Dispose(); } } } List <DocumentInTransactionData> changes = null; using (storage.SetTransactionContext(context)) { storage.Batch(accessor => { var itemsToTouch = RunOperationsInTransaction(id, out changes); context.ItemsToTouch = itemsToTouch; }); } if (changes == null) { return; } // independent storage transaction, will actually commit here storage.Batch(accessor => { var jsonSerializer = JsonExtensions.CreateDefaultJsonSerializer(); var data = new RavenJObject { { "Changes", RavenJToken.FromObject(changes, jsonSerializer) }, { "ResourceManagerId", resourceManagerId.ToString() }, { "RecoveryInformation", recoveryInformation } }; accessor.Lists.Set("Raven/Transactions/Pending", id, data, UuidType.DocumentTransactions); }); } catch (Exception) { Rollback(id); throw; } }
protected static void SerializeError(IHttpContext ctx, object error) { var sw = new StreamWriter(ctx.Response.OutputStream); JsonExtensions.CreateDefaultJsonSerializer().Serialize(new JsonTextWriter(sw) { Formatting = Formatting.Indented, }, error); sw.Flush(); }
public async Task CanUseMultiQuery() { using (var store = GetDocumentStore()) { using (var session = store.OpenSession()) { session.Store(new User { Name = "Ayende" }); session.Store(new User { Name = "Oren" }); session.SaveChanges(); } using (var session = store.OpenSession()) { session.Query <User>() .Customize(x => x.WaitForNonStaleResults()) .Where(u => u.Name == "Ayende") .ToArray(); } var request = (HttpWebRequest)WebRequest.Create(store.Url.ForDatabase(store.DefaultDatabase) + "/multi_get"); request.Method = "POST"; using (var stream = await request.GetRequestStreamAsync()) { var streamWriter = new StreamWriter(stream); JsonExtensions.CreateDefaultJsonSerializer().Serialize(streamWriter, new[] { new GetRequest { Url = "/indexes/dynamic/Users", Query = "query=Name:Ayende" }, new GetRequest { Url = "/indexes/dynamic/Users", Query = "query=Name:Oren" }, }); streamWriter.Flush(); stream.Flush(); } using (var resp = await request.GetResponseAsync()) using (var stream = resp.GetResponseStream()) { var result = new StreamReader(stream).ReadToEnd(); Assert.Contains("Ayende", result); Assert.Contains("Oren", result); } } }
public async Task <SynchronizationReport> PushChangesAsync(CancellationToken token) { token.Register(() => { });//request.Abort() TODO: check this token.ThrowIfCancellationRequested(); if (sourceStream.CanRead == false) { throw new Exception("Stream does not support reading"); } var baseUrl = synchronizationServerClient.BaseUrl; var credentials = synchronizationServerClient.Credentials; var conventions = synchronizationServerClient.Conventions; var requestParams = new CreateHttpJsonRequestParams(this, baseUrl + "/synchronization/MultipartProceed", "POST", credentials, conventions, timeout: TimeSpan.FromHours(12)) { DisableRequestCompression = true }; using (var request = synchronizationServerClient.RequestFactory.CreateHttpJsonRequest(requestParams)) { request.AddHeaders(sourceMetadata); request.AddHeader("Content-Type", "multipart/form-data; boundary=" + syncingBoundary); request.AddHeader("If-None-Match", "\"" + sourceMetadata.Value <string>(Constants.MetadataEtagField) + "\""); request.AddHeader(SyncingMultipartConstants.FileName, fileName); request.AddHeader(SyncingMultipartConstants.SourceFileSystemInfo, fileSystemInfo.AsJson()); try { await request.WriteAsync(PrepareMultipartContent(token)).ConfigureAwait(false); var response = await request.ReadResponseJsonAsync().ConfigureAwait(false); return(JsonExtensions.CreateDefaultJsonSerializer().Deserialize <SynchronizationReport>(new RavenJTokenReader(response))); } catch (Exception exception) { if (token.IsCancellationRequested) { throw new OperationCanceledException(token); } var webException = exception as ErrorResponseException; if (webException != null) { webException.SimplifyException(); } throw; } } }
public HttpResponseMessage InfoPackage() { var tempFileName = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); try { var jsonSerializer = JsonExtensions.CreateDefaultJsonSerializer(); jsonSerializer.Formatting = Formatting.Indented; using (var file = new FileStream(tempFileName, FileMode.Create)) using (var package = new ZipArchive(file, ZipArchiveMode.Create)) { var adminStats = package.CreateEntry("admin_stats.txt", CompressionLevel.Optimal); using (var metricsStream = adminStats.Open()) using (var streamWriter = new StreamWriter(metricsStream)) { jsonSerializer.Serialize(streamWriter, CreateAdminStats()); streamWriter.Flush(); } DatabasesLandlord.ForAllDatabases(database => { var prefix = string.IsNullOrWhiteSpace(database.Name) ? "System" : database.Name; DebugInfoProvider.CreateInfoPackageForDatabase(package, database, RequestManager, prefix + "/"); }); var stacktraceRequsted = GetQueryStringValue("stacktrace"); if (stacktraceRequsted != null) { DumpStacktrace(package); } } var response = new HttpResponseMessage(); response.Content = new StreamContent(new FileStream(tempFileName, FileMode.Open, FileAccess.Read)) { Headers = { ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = string.Format("Admin-Debug-Info-{0}.zip",SystemTime.UtcNow), }, ContentType = new MediaTypeHeaderValue("application/octet-stream") } }; return(response); } finally { IOExtensions.DeleteFile(tempFileName); } }
static ErrorPersister() { Serializer = JsonExtensions.CreateDefaultJsonSerializer(); Serializer.TypeNameHandling = TypeNameHandling.Auto; JObjectMetadata = RavenJObject.Parse($@" {{ ""Raven-Entity-Name"": ""{FailedMessage.CollectionName}"", ""Raven-Clr-Type"": ""{typeof(FailedMessage).AssemblyQualifiedName}"" }}"); }
public CounterStore() { JsonSerializer = JsonExtensions.CreateDefaultJsonSerializer(); JsonRequestFactory = new HttpJsonRequestFactory(Constants.NumberOfCachedRequests); CountersConvention = new CountersConvention(); Credentials = new OperationCredentials(null, CredentialCache.DefaultNetworkCredentials); Advanced = new CounterStoreAdvancedOperations(this); Admin = new CounterStoreAdminOperations(this); batch = new Lazy <BatchOperationsStore>(() => new BatchOperationsStore(this)); isInitialized = false; }
public byte[] AsBytes() { var memoryStream = new MemoryStream(); var streamWriter = new StreamWriter(memoryStream); JsonExtensions.CreateDefaultJsonSerializer().Serialize(streamWriter, this); streamWriter.Flush(); return(memoryStream.ToArray()); }
public static T ReadJsonObject <T>(this IHttpContext context) { using (var streamReader = new StreamReader(context.Request.InputStream, GetRequestEncoding(context))) { var readToEnd = streamReader.ReadToEnd(); using (var jsonReader = new RavenJsonTextReader(new StringReader(readToEnd))) { var result = JsonExtensions.CreateDefaultJsonSerializer(); return((T)result.Deserialize(jsonReader, typeof(T))); } } }
public static DocumentAuthorization GetAuthorizationFor(this IDocumentSession session, object entity) { var metadata = session.Advanced.GetMetadataFor(entity); var docAuthAsJson = metadata[RavenDocumentAuthorization]; if (docAuthAsJson == null) { return(null); } var jsonSerializer = JsonExtensions.CreateDefaultJsonSerializer(); jsonSerializer.ContractResolver = session.Advanced.DocumentStore.Conventions.JsonContractResolver; return(jsonSerializer.Deserialize <DocumentAuthorization>(new RavenJTokenReader(docAuthAsJson))); }
public async Task <T> ReadJsonObjectAsync <T>() { using (var stream = await InnerRequest.Content.ReadAsStreamAsync()) using (var gzipStream = new GZipStream(stream, CompressionMode.Decompress)) using (var streamReader = new StreamReader(stream, GetRequestEncoding())) { using (var jsonReader = new JsonTextReader(streamReader)) { var result = JsonExtensions.CreateDefaultJsonSerializer(); return((T)result.Deserialize(jsonReader, typeof(T))); } } }
public override async Task Run(IDictionary <string, object> websocketContext) { var sendAsync = (WebSocketSendAsync)websocketContext["websocket.SendAsync"]; var closeAsync = (WebSocketCloseAsync)websocketContext["websocket.CloseAsync"]; var callCancelled = (CancellationToken)websocketContext["websocket.CallCancelled"]; int statusCode = 200; string statusMessage = "OK"; try { var parser = WebSocketsRequestParser; await parser.ParseWebSocketRequestAsync(_context.Request.Uri, _context.Request.Query["singleUseAuthToken"]).ConfigureAwait(false); } catch (WebSocketsRequestParser.WebSocketRequestValidationException e) { statusCode = (int)e.StatusCode; statusMessage = string.IsNullOrEmpty(e.Message) == false ? e.Message : string.Empty; } using (var memoryStream = new MemoryStream()) { var serializer = JsonExtensions.CreateDefaultJsonSerializer(); await SendMessage(memoryStream, serializer, new { StatusCode = statusCode, StatusMessage = statusMessage, Time = SystemTime.UtcNow }, sendAsync, callCancelled).ConfigureAwait(false); } try { var buffer = new ArraySegment <byte>(new byte[1024]); var receiveAsync = (WebSocketReceiveAsync)websocketContext["websocket.ReceiveAsync"]; var receiveResult = await receiveAsync(buffer, callCancelled).ConfigureAwait(false); if (receiveResult.Item1 == WebSocketCloseMessageType) { var clientCloseStatus = (int)websocketContext["websocket.ClientCloseStatus"]; var clientCloseDescription = (string)websocketContext["websocket.ClientCloseDescription"]; if (clientCloseStatus == NormalClosureCode && clientCloseDescription == NormalClosureMessage) { await closeAsync(clientCloseStatus, clientCloseDescription, callCancelled).ConfigureAwait(false); } } } catch (Exception e) { Log.WarnException("Error when receiving message from web socket transport", e); throw; } }
public void FileHeaderSerialization() { var metadata = new RavenJObject { { Constants.LastModified, "2014-07-07T12:00:00.0000000" }, { Constants.FileSystem.RavenFsSize, "128" } }; var fileHeader = new FileHeader("test1.file", metadata); var serializedValue = JsonExtensions.ToJObject(fileHeader); var jr = new RavenJTokenReader(serializedValue); var deserializedValue = JsonExtensions.CreateDefaultJsonSerializer().Deserialize <FileHeader>(jr); Assert.NotNull(deserializedValue); Assert.Equal(fileHeader.Name, deserializedValue.Name); Assert.Equal(fileHeader.LastModified, deserializedValue.LastModified); }
public async Task CanUseMultiGetToBatchGetDocumentRequests() { using (var store = GetDocumentStore()) { var docs = $"/databases/{store.DefaultDatabase}/docs"; using (var session = store.OpenSession()) { session.Store(new User { Name = "Ayende" }); session.Store(new User { Name = "Oren" }); session.SaveChanges(); } var request = (HttpWebRequest)WebRequest.Create(store.Url.ForDatabase(store.DefaultDatabase) + "/multi_get"); request.Method = "POST"; using (var stream = await request.GetRequestStreamAsync()) { var streamWriter = new StreamWriter(stream); JsonExtensions.CreateDefaultJsonSerializer().Serialize(streamWriter, new[] { new GetRequest { Url = docs, Query = "?id=users/1" }, new GetRequest { Url = docs, Query = "?id=users/2" }, }); streamWriter.Flush(); stream.Flush(); } using (var resp = await request.GetResponseAsync()) using (var stream = resp.GetResponseStream()) { var result = new StreamReader(stream).ReadToEnd(); Assert.Contains("Ayende", result); Assert.Contains("Oren", result); } } }
public void CanUseMultiGetToBatchGetDocumentRequests() { using (GetNewServer()) using (var docStore = new DocumentStore { Url = "http://localhost:8079" }.Initialize()) { using (var session = docStore.OpenSession()) { session.Store(new User { Name = "Ayende" }); session.Store(new User { Name = "Oren" }); session.SaveChanges(); } var request = (HttpWebRequest)WebRequest.Create("http://localhost:8079/multi_get"); request.Method = "POST"; using (var stream = request.GetRequestStream()) { var streamWriter = new StreamWriter(stream); JsonExtensions.CreateDefaultJsonSerializer().Serialize(streamWriter, new[] { new GetRequest { Url = "/docs/users/1" }, new GetRequest { Url = "/docs/users/2" }, }); streamWriter.Flush(); stream.Flush(); } using (var resp = request.GetResponse()) using (var stream = resp.GetResponseStream()) { var result = new StreamReader(stream).ReadToEnd(); Assert.Contains("Ayende", result); Assert.Contains("Oren", result); } } }
private RavenJArray PerformBulkOperation(string index, IndexQuery indexQuery, bool allowStale, Func <string, TransactionInformation, object> batchOperation) { var array = new RavenJArray(); var bulkIndexQuery = new IndexQuery { Query = indexQuery.Query, Start = indexQuery.Start, Cutoff = indexQuery.Cutoff, PageSize = int.MaxValue, FieldsToFetch = new[] { Constants.DocumentIdFieldName }, SortedFields = indexQuery.SortedFields }; bool stale; var queryResults = database.QueryDocumentIds(index, bulkIndexQuery, out stale); if (stale && allowStale == false) { throw new InvalidOperationException( "Bulk operation cancelled because the index is stale and allowStale is false"); } const int batchSize = 1024; using (var enumerator = queryResults.GetEnumerator()) { while (true) { var batchCount = 0; database.TransactionalStorage.Batch(actions => { while (batchCount < batchSize && enumerator.MoveNext()) { batchCount++; var result = batchOperation(enumerator.Current, transactionInformation); array.Add(RavenJObject.FromObject(result, JsonExtensions.CreateDefaultJsonSerializer())); } }); if (batchCount < batchSize) { break; } } } return(array); }
public void ConflictNotificationSerialization() { var metadata = new RavenJObject { { Constants.LastModified, "2014-07-07T12:00:00.0000000" }, { Constants.FileSystem.RavenFsSize, "128" } }; var fileHeader = new FileHeader("test1.file", metadata); var notification = new ConflictNotification() { FileName = "test1.file", SourceServerUrl = "http://destination", RemoteFileHeader = fileHeader, Status = ConflictStatus.Detected }; var serializedValue = JsonExtensions.ToJObject(notification); var jr = new RavenJTokenReader(serializedValue); var deserializedValue = JsonExtensions.CreateDefaultJsonSerializer().Deserialize <ConflictNotification>(jr); Assert.NotNull(deserializedValue); }
public Task <HttpResponseMessage> ExportDatabase(ExportData smugglerOptionsJson) { var requestString = smugglerOptionsJson.SmugglerOptions; SmugglerDatabaseOptions smugglerOptions; using (var jsonReader = new RavenJsonTextReader(new StringReader(requestString))) { var serializer = JsonExtensions.CreateDefaultJsonSerializer(); smugglerOptions = (SmugglerDatabaseOptions)serializer.Deserialize(jsonReader, typeof(SmugglerDatabaseOptions)); } var result = GetEmptyMessage(); // create PushStreamContent object that will be called when the output stream will be ready. result.Content = new PushStreamContent(async(outputStream, content, arg3) => { try { var dataDumper = new DatabaseDataDumper(Database, smugglerOptions); await dataDumper.ExportData( new SmugglerExportOptions <RavenConnectionStringOptions> { ToStream = outputStream }).ConfigureAwait(false); } finally { outputStream.Close(); } }); var fileName = String.IsNullOrEmpty(smugglerOptions.NoneDefualtFileName) || (smugglerOptions.NoneDefualtFileName.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0) ? string.Format("Dump of {0}, {1}", this.DatabaseName, DateTime.Now.ToString("yyyy-MM-dd HH-mm", CultureInfo.InvariantCulture)) : smugglerOptions.NoneDefualtFileName; result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = fileName + ".ravendump" }; return(new CompletedTask <HttpResponseMessage>(result)); }
private void HandleDataReuqest(HttpContext context) { context.Response.ContentType = "application/json"; var rawIds = context.Request.QueryString.GetValues("id") ?? context.Request.QueryString.GetValues("id[]") ?? Enumerable.Empty <string>(); var ids = rawIds.Select(Guid.Parse); var items = from documentStore in stores.Keys from id in ids let profilingInformation = documentStore.GetProfilingInformationFor(id) where profilingInformation != null select jsonFormatterAndFieldsFilterer.Filter(profilingInformation); var results = items.ToList(); JsonExtensions.CreateDefaultJsonSerializer().Serialize(context.Response.Output, results); context.Response.Output.Flush(); }