private IndexDefinition DirectGetIndex(string indexName, string operationUrl) { var httpJsonRequest = HttpJsonRequest.CreateHttpJsonRequest(this, operationUrl + "/indexes/" + indexName + "?definition=yes", "GET", credentials); httpJsonRequest.AddOperationHeaders(OperationsHeaders); string indexDefAsString; try { indexDefAsString = httpJsonRequest.ReadResponseString(); } catch (WebException e) { var httpWebResponse = e.Response as HttpWebResponse; if (httpWebResponse != null && httpWebResponse.StatusCode == HttpStatusCode.NotFound) { return(null); } throw; } var indexDefResultAsJson = JObject.Load(new JsonTextReader(new StringReader(indexDefAsString))); return(convention.CreateSerializer().Deserialize <IndexDefinition>( new JTokenReader(indexDefResultAsJson["Index"]) )); }
/// <summary> /// Begins the async query. /// </summary> /// <param name="index">The index.</param> /// <param name="query">The query.</param> /// <param name="includes">The include paths</param> public Task <QueryResult> QueryAsync(string index, IndexQuery query, string[] includes) { EnsureIsNotNullOrEmpty(index, "index"); var path = query.GetIndexQueryUrl(url, index, "indexes"); if (includes != null && includes.Length > 0) { path += "&" + string.Join("&", includes.Select(x => "include=" + x).ToArray()); } var request = HttpJsonRequest.CreateHttpJsonRequest(this, path, "GET", credentials, convention); return(Task.Factory.FromAsync <string>(request.BeginReadResponseString, request.EndReadResponseString, null) .ContinueWith(task => { JToken json; using (var reader = new JsonTextReader(new StringReader(task.Result))) json = (JToken)convention.CreateSerializer().Deserialize(reader); return new QueryResult { IsStale = Convert.ToBoolean(json["IsStale"].ToString()), IndexTimestamp = json.Value <DateTime>("IndexTimestamp"), IndexEtag = new Guid(request.ResponseHeaders["ETag"]), Results = json["Results"].Children().Cast <JObject>().ToList(), TotalResults = Convert.ToInt32(json["TotalResults"].ToString()), IndexName = json.Value <string>("IndexName"), SkippedResults = Convert.ToInt32(json["SkippedResults"].ToString()) }; })); }
/// <summary> /// Puts the document with the specified key in the database /// </summary> /// <param name="key">The key.</param> /// <param name="etag">The etag.</param> /// <param name="document">The document.</param> /// <param name="metadata">The metadata.</param> public Task <PutResult> PutAsync(string key, Guid?etag, RavenJObject document, RavenJObject metadata) { if (metadata == null) { metadata = new RavenJObject(); } var method = String.IsNullOrEmpty(key) ? "POST" : "PUT"; if (etag != null) { metadata["ETag"] = new RavenJValue(etag.Value.ToString()); } var request = jsonRequestFactory.CreateHttpJsonRequest(this, url + "/docs/" + key, method, metadata, credentials, convention); request.AddOperationHeaders(OperationsHeaders); return(Task.Factory.FromAsync(request.BeginWrite, request.EndWrite, document.ToString(), null) .ContinueWith(task => { if (task.Exception != null) { throw new InvalidOperationException("Unable to write to server"); } return request.ReadResponseJsonAsync() .ContinueWith(task1 => { try { return convention.CreateSerializer().Deserialize <PutResult>(new RavenJTokenReader(task1.Result)); } catch (AggregateException e) { var we = e.ExtractSingleInnerException() as WebException; if (we == null) { throw; } var httpWebResponse = we.Response as HttpWebResponse; if (httpWebResponse == null || httpWebResponse.StatusCode != HttpStatusCode.Conflict) { throw; } throw ThrowConcurrencyException(we); } }); }) .Unwrap()); }
private void UpdateIndexInReplication(IDatabaseCommands databaseCommands, DocumentConvention documentConvention, IndexDefinition indexDefinition) { var serverClient = databaseCommands as ServerClient; if (serverClient == null) { return; } var doc = serverClient.Get("Raven/Replication/Destinations"); if (doc == null) { return; } var replicationDocument = documentConvention.CreateSerializer().Deserialize <ReplicationDocument>(new RavenJTokenReader(doc.DataAsJson)); if (replicationDocument == null) { return; } foreach (var replicationDestination in replicationDocument.Destinations) { try { serverClient.DirectPutIndex(IndexName, replicationDestination.Url, true, indexDefinition); } catch (Exception e) { Logger.WarnException("Could not put index in replication server", e); } } }
private List <Alert> DeserializeAlerts(MemoryStream ms) { var conventions = new DocumentConvention(); var alertList = RavenJToken.TryLoad(ms) as RavenJArray; return((List <Alert>)conventions.CreateSerializer().Deserialize(new RavenJTokenReader(alertList), typeof(List <Alert>))); }
public Task Migrate <TMigration, TEntity>(TMigration migration) where TMigration : IMigration <TEntity> where TEntity : IEntity { int count; using (var session = _store.OpenSession(_databaseName)) { count = session.Query <TEntity>(). Customize(query => query.WaitForNonStaleResultsAsOfLastWrite()). //This is here because the streaming API will only use existing indexes, not create its own dynamically Count(); } QueryHeaderInformation info; var documents = _store.DatabaseCommands.ForDatabase(_databaseName).StreamQuery("Raven/DocumentsByEntityName", new IndexQuery { Query = "Tag: SillyEntities" }, out info); while (documents.MoveNext()) { var documentConvention = new DocumentConvention(); var entity = (TEntity)(documentConvention.CreateSerializer().Deserialize(new RavenJTokenReader(documents.Current), typeof(TEntity))); migration.Migrate(entity); } return(Task.FromResult(true)); }
public void LinqQueryWithStaticCallOnEnumerableIsCanBeCompiledAndRun() { var indexDefinition = new IndexDefinition <Page> { Map = pages => from p in pages from coAuthor in p.CoAuthors.DefaultIfEmpty() select new { p.Id, CoAuthorUserID = coAuthor != null ? coAuthor.UserId : -1 } }.ToIndexDefinition(new DocumentConvention()); var mapInstance = new DynamicViewCompiler("testView", indexDefinition, new AbstractDynamicCompilationExtension[] { }). GenerateInstance(); var conventions = new DocumentConvention(); var o = JObject.FromObject(page, conventions.CreateSerializer()); o["@metadata"] = new JObject( new JProperty("Raven-Entity-Name", "Pages") ); dynamic dynamicObject = new DynamicJsonObject(o); var result = mapInstance.MapDefinition(new[] { dynamicObject }).ToList <object>(); Assert.Equal("{ Id = 0, CoAuthorUserID = 1, __document_id = }", result[0].ToString()); Assert.Equal("{ Id = 0, CoAuthorUserID = 2, __document_id = }", result[1].ToString()); }
/// <summary> /// Returns a list of suggestions based on the specified suggestion query. /// </summary> /// <param name="index">The index to query for suggestions</param> /// <param name="suggestionQuery">The suggestion query.</param> public Task <SuggestionQueryResult> SuggestAsync(string index, SuggestionQuery suggestionQuery) { if (suggestionQuery == null) { throw new ArgumentNullException("suggestionQuery"); } var requestUri = url + string.Format("/suggest/{0}?term={1}&field={2}&max={3}&distance={4}&accuracy={5}", Uri.EscapeUriString(index), Uri.EscapeDataString(suggestionQuery.Term), Uri.EscapeDataString(suggestionQuery.Field), Uri.EscapeDataString(suggestionQuery.MaxSuggestions.ToString()), Uri.EscapeDataString(suggestionQuery.Distance.ToString()), Uri.EscapeDataString(suggestionQuery.Accuracy.ToString())); var request = jsonRequestFactory.CreateHttpJsonRequest(this, requestUri, "GET", credentials, convention); request.AddOperationHeaders(OperationsHeaders); var serializer = convention.CreateSerializer(); return(Task.Factory.FromAsync <string>(request.BeginReadResponseString, request.EndReadResponseString, null) .ContinueWith(task => { using (var reader = new JsonTextReader(new StringReader(task.Result))) { var json = (RavenJObject)serializer.Deserialize(reader); return new SuggestionQueryResult { Suggestions = ((RavenJArray)json["Suggestions"]).Select(x => x.Value <string>()).ToArray(), }; } })); }
public BlittableJsonReaderObject ConvertEntityToBlittable(object entity, DocumentConvention documentConvention, JsonOperationContext jsonOperationContext, DocumentInfo documentInfo = null) { var writer = new BlittableJsonWriter(jsonOperationContext, documentInfo); var serializer = documentConvention.CreateSerializer(); serializer.Serialize(writer, entity); writer.FinalizeDocument(); var reader = writer.CreateReader(); return(reader); }
public void ListOnDynamicJsonObjectFromJsonWillFailToBeAJsonList() { var conventions = new DocumentConvention(); var jObject = JObject.FromObject(page, conventions.CreateSerializer()); dynamic dynamicObject = new DynamicJsonObject(jObject); Assert.NotNull(dynamicObject.CoAuthors as IEnumerable); Assert.NotNull(dynamicObject.CoAuthors.Length); Assert.Equal(2, dynamicObject.CoAuthors.Length); }
public Task <LogItem[]> GetLogsAsync(bool errorsOnly) { var requestUri = url + "/logs"; if (errorsOnly) { requestUri += "?type=error"; } var request = jsonRequestFactory.CreateHttpJsonRequest(this, requestUri.NoCache(), "GET", credentials, convention); request.AddOperationHeaders(OperationsHeaders); return(request.ReadResponseStringAsync() .ContinueWith(task => { using (var reader = new JsonTextReader(new StringReader(task.Result))) { return convention.CreateSerializer().Deserialize <LogItem[]>(reader); } })); }
/// <summary> /// Perform a single POST request containing multiple nested GET requests /// </summary> public Task <GetResponse[]> MultiGetAsync(GetRequest[] requests) { var postedData = JsonConvert.SerializeObject(requests); var httpJsonRequest = jsonRequestFactory.CreateHttpJsonRequest(this, url + "/multi_get/", "POST", credentials, convention); return(httpJsonRequest.WriteAsync(postedData) .ContinueWith( task => { task.Wait(); // will throw if write errored return httpJsonRequest.ReadResponseJsonAsync() .ContinueWith(replyTask => convention.CreateSerializer().Deserialize <GetResponse[]>(new RavenJTokenReader(replyTask.Result))); }) .Unwrap()); }
private SupportCoverageResult QueryForSupportCoverage(string id) { try { var requestParam = new CreateHttpJsonRequestParams(null, "http://licensing.ravendb.net/license/support/" + id, HttpMethod.Get, null, null, conventions); using (var request = requestFactory.CreateHttpJsonRequest(requestParam)) { var value = request.ReadResponseJson(); return(conventions.CreateSerializer().Deserialize <SupportCoverageResult>(new RavenJTokenReader(value))); } } catch (Exception e) { log.WarnException("Failed to obtain support coverage information.", e); return(CreateDefaultSupportCoverageDocument()); } }
private Task UpdateIndexInReplicationAsync(IAsyncDatabaseCommands asyncDatabaseCommands, DocumentConvention documentConvention, IndexDefinition indexDefinition) { var asyncServerClient = asyncDatabaseCommands as AsyncServerClient; if (asyncServerClient == null) { return(new CompletedTask()); } return(asyncServerClient.GetAsync("Raven/Replication/Destinations").ContinueWith(doc => { if (doc == null) { return new CompletedTask(); } var replicationDocument = documentConvention.CreateSerializer().Deserialize <ReplicationDocument>(new RavenJTokenReader(doc.Result.DataAsJson)); if (replicationDocument == null) { return new CompletedTask(); } var tasks = new List <Task>(); foreach (var replicationDestination in replicationDocument.Destinations) { if (replicationDestination.Disabled || replicationDestination.IgnoredClient) { continue; } tasks.Add(asyncServerClient.DirectPutIndexAsync(IndexName, indexDefinition, true, GetReplicationUrl(replicationDestination))); } return Task.Factory.ContinueWhenAll(tasks.ToArray(), indexingTask => { foreach (var indexTask in indexingTask) { if (indexTask.IsFaulted) { Logger.WarnException("Could not put index in replication server", indexTask.Exception); } } }); }).Unwrap()); }
public void CanSerializeYieldGetterMethods() { // If this test breaks, this is likely becaused we merged // a new version of JSON.Net, which can revert a modification that we made to the code // Look at the other changes that happened in this commit (see the git log for that) // And at any rate, the full explanation, including the full reasoning is here: // http://issues.hibernatingrhinos.com/issue/RavenDB-3931 // // Don't try to fix this issue without reading the details, it is a single line fix, but it // takes time to get to the right reason var documentConvention = new DocumentConvention(); var jsonSerializer = documentConvention.CreateSerializer(); var stringWriter = new StringWriter(); jsonSerializer.Serialize(stringWriter, new Item()); var str = stringWriter.GetStringBuilder().ToString(); jsonSerializer.Deserialize <Item>(new JsonTextReader(new StringReader(str))); }
internal async Task UpdateIndexInReplicationAsync(IAsyncDatabaseCommands asyncDatabaseCommands, DocumentConvention documentConvention, Func <AsyncServerClient, OperationMetadata, Task> action) { var asyncServerClient = asyncDatabaseCommands as AsyncServerClient; if (asyncServerClient == null) { return; } var doc = await asyncServerClient.GetAsync("Raven/Replication/Destinations"); if (doc == null) { return; } var replicationDocument = documentConvention.CreateSerializer().Deserialize <ReplicationDocument>(new RavenJTokenReader(doc.DataAsJson)); if (replicationDocument == null || replicationDocument.Destinations == null || replicationDocument.Destinations.Count == 0) { return; } var tasks = ( from replicationDestination in replicationDocument.Destinations where !replicationDestination.Disabled && !replicationDestination.IgnoredClient select action(asyncServerClient, GetReplicationOperation(replicationDestination)) ) .ToArray(); await Task.Factory.ContinueWhenAll(tasks, indexingTask => { foreach (var indexTask in indexingTask) { if (indexTask.IsFaulted) { Logger.WarnException("Could not put index in replication server", indexTask.Exception); } } }); }
internal void UpdateIndexInReplication(IDatabaseCommands databaseCommands, DocumentConvention documentConvention, Action <ServerClient, OperationMetadata> action) { var serverClient = databaseCommands as ServerClient; if (serverClient == null) { return; } var doc = serverClient.Get("Raven/Replication/Destinations"); if (doc == null) { return; } var replicationDocument = documentConvention.CreateSerializer().Deserialize <ReplicationDocument>(new RavenJTokenReader(doc.DataAsJson)); if (replicationDocument == null) { return; } foreach (var replicationDestination in replicationDocument.Destinations) { try { if (replicationDestination.Disabled || replicationDestination.IgnoredClient) { continue; } action(serverClient, GetReplicationOperation(replicationDestination)); } catch (Exception e) { Logger.WarnException("Could not put index in replication server", e); } } }
private TcpConnectionInfo GetTcpInfo() { var convention = new DocumentConvention(); //since we use it only once when the connection is initialized, no reason to keep requestFactory around for long using (var requestFactory = new HttpJsonRequestFactory(1)) using (var request = requestFactory.CreateHttpJsonRequest(new CreateHttpJsonRequestParams(null, string.Format("{0}/info/tcp", MultiDatabase.GetRootDatabaseUrl(_destination.Url)), HttpMethod.Get, new OperationCredentials(_destination.ApiKey, CredentialCache.DefaultCredentials), convention) { Timeout = TimeSpan.FromSeconds(15) })) { var result = request.ReadResponseJson(); var tcpConnectionInfo = convention.CreateSerializer().Deserialize <TcpConnectionInfo>(new RavenJTokenReader(result)); if (_log.IsInfoEnabled) { _log.Info($"Will replicate to {_destination.Database} @ {_destination.Url} via {tcpConnectionInfo.Url}"); } return(tcpConnectionInfo); } }
/// <summary> /// Deserializes the specified instance <param name="self"/> to an instance of <param name="type"/> using the specified <param name="convention"/> /// </summary> public static object Deserialize(this JObject self, Type type, DocumentConvention convention) { return(convention.CreateSerializer().Deserialize(new JTokenReader(self), type)); }
/// <summary> /// Deserializes the specified instance <param name="self"/> to an instance of <typeparam name="T"/> using the specified <param name="convention"/> /// </summary> public static T Deserialize <T>(this JObject self, DocumentConvention convention) { return((T)convention.CreateSerializer().Deserialize(new JTokenReader(self), typeof(T))); }
public void Register(IServiceCollection services) { var documentStore = DocumentStoreFactory.CreateStore(_connectionString, Assembly.GetExecutingAssembly()); services.AddSingleton <IDocumentStore>(documentStore); var filesStore = FileStoreFactory.CreateStore(_connectionString); services.AddSingleton <IFilesStore>(filesStore); services.AddScoped <IDocumentSession>(x => { var docStore = x.GetService <IDocumentStore>(); var documentConvention = new DocumentConvention(); var jsonSerializer = documentConvention.CreateSerializer(); docStore.Conventions.CreateSerializer(); return(docStore.OpenSession()); }); services.AddScoped <IAsyncDocumentSession>(x => x.GetService <IDocumentStore>().OpenAsyncSession()); services.AddScoped <IAsyncFilesSession>(x => x.GetService <IFilesStore>().OpenAsyncSession()); services.AddScoped <IIdentityGenerator, RavenIdentityGenerator>(); services.AddScoped <IRavenIdentityGenerator, RavenIdentityGenerator>(); //Repositories services.AddScoped <IBookingPositionRepository, RavenBookingPositionRepository>(); services.AddScoped <IBookingPositionGroupRepository, RavenBookingPositionGroupRepository>(); services.AddScoped <IUniverseRepository, RavenUniverseRepository>(); services.AddScoped <ISalesAreaRepository, RavenSalesAreaRepository>(); services.AddScoped <IDemographicRepository, RavenDemographicRepository>(); services.AddScoped <IMetadataRepository, RavenMetadataRepository>(); services.AddScoped <IScheduleRepository, RavenScheduleRepository>(); services.AddScoped <IProgrammeRepository, RavenProgrammeRepository>(); services.AddScoped <IProgrammeClassificationRepository, RavenProgrammeClassificationRepository>(); services.AddScoped <IClashRepository, RavenClashRepository>(); services.AddScoped <IProductRepository, RavenProductRepository>(); services.AddScoped <IRatingsScheduleRepository, RavenRatingsScheduleRepository>(); services.AddScoped <IRestrictionRepository, RavenRestrictionRepository>(); services.AddScoped <IClearanceRepository, RavenClearanceRepository>(); services.AddScoped <ISpotRepository, RavenSpotRepository>(); services.AddScoped <IBreakRepository, RavenBreakRepository>(); services.AddScoped <IBusinessTypeRepository, RavenBusinessTypeRepository>(); services.AddScoped <IClashExceptionRepository, RavenClashExceptionRepository>(); services.AddScoped <ICampaignRepository, RavenCampaignRepository>(); services.AddScoped <ICampaignSettingsRepository, RavenCampaignSettingsRepository>(); services.AddScoped <ITenantSettingsRepository, RavenTenantSettingsRepository>(); services.AddScoped <IScenarioRepository, RavenScenarioRepository>(); services.AddScoped <IPassRepository, RavenPassRepository>(); services.AddScoped <ISalesAreaDemographicRepository, RavenSalesAreaDemographicRepository>(); services.AddScoped <IProgrammeCategoryHierarchyRepository, RavenProgrammeCategoryHierarchyRepository>(); services.AddScoped <IProgrammeEpisodeRepository, RavenProgrammeEpisodeRepository>(); services.AddScoped <IInventoryTypeRepository, RavenInventoryTypeRepository>(); services.AddScoped <IInventoryLockRepository, RavenInventoryLockRepository>(); services.AddScoped <ILockTypeRepository, RavenLockTypeRepository>(); services.AddScoped <ITotalRatingRepository, RavenTotalRatingRepository>(); services.AddScoped <IStandardDayPartRepository, RavenStandardDayPartRepository>(); services.AddScoped <IStandardDayPartGroupRepository, RavenStandardDayPartGroupRepository>(); services.AddScoped <ILengthFactorRepository, RavenLengthFactorRepository>(); // ValidationServices services.AddScoped <IClashExceptionValidations, ClashExceptionValidations>(); }