protected override void BeforeSerialize(IElasticsearchClientSettings settings)
{
if (Index is null)
{
Index = settings.Inferrer.IndexName <TPartialDocument>();
}
}
public DefaultRequestResponseSerializer(IElasticsearchClientSettings settings)
{
Options = new JsonSerializerOptions
{
DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
IncludeFields = true,
Converters =
{
new SourceConverterFactory(settings),
new ReadOnlyIndexNameDictionaryConverterFactory(settings),
new CalendarIntervalConverter(),
new IndexNameConverter(settings),
new ObjectToInferredTypesConverter(),
new IdConverter(settings),
new FieldConverter(settings),
new FieldValuesConverter(settings),
new SortCollectionConverter(settings),
new LazyDocumentConverter(settings),
new RelationNameConverter(settings),
new CustomJsonWriterConverterFactory(settings),
new RoutingConverter(settings),
new SelfSerializableConverterFactory(settings),
new SelfDeserializableConverterFactory(settings),
new SelfTwoWaySerializableConverterFactory(settings),
new IndicesJsonConverter(settings),
new DictionaryConverter(),
new IsADictionaryConverter(),
new UnionConverter()
},
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
_settings = settings;
}
protected override string ResolveUrl(RouteValues routeValues, IElasticsearchClientSettings settings)
{
if (Pit is not null && !string.IsNullOrEmpty(Pit.Id ?? string.Empty) && routeValues.ContainsKey("index"))
{
routeValues.Remove("index");
}
return(base.ResolveUrl(routeValues, settings));
}
protected override string ResolveUrl(RouteValues routeValues, IElasticsearchClientSettings settings)
{
if ((Self.PitValue is not null || Self.PitDescriptor is not null || Self.PitDescriptorAction is not null) && routeValues.ContainsKey("index"))
{
routeValues.Remove("index");
}
return(base.ResolveUrl(routeValues, settings));
}
public JsonNetSerializer(
Serializer builtinSerializer,
IElasticsearchClientSettings connectionSettings,
Func <JsonSerializerSettings> jsonSerializerSettingsFactory = null,
Action <ConnectionSettingsAwareContractResolver> modifyContractResolver = null,
IEnumerable <JsonConverter> contractJsonConverters = null
)
: base(builtinSerializer, connectionSettings, jsonSerializerSettingsFactory, modifyContractResolver, contractJsonConverters)
{
}
private void SerializeOperationAction(IElasticsearchClientSettings settings, Utf8JsonWriter writer)
{
var requestResponseSerializer = settings.RequestResponseSerializer;
writer.WriteStartObject();
writer.WritePropertyName(Operation);
requestResponseSerializer.TryGetJsonSerializerOptions(out var options);
WriteOperation(writer, options);
writer.WriteEndObject();
}
public static void SerializeParams <T>(T toSerialize, Utf8JsonWriter writer, IElasticsearchClientSettings settings)
{
if (settings.Experimental.UseSourceSerializerForScriptParameters)
{
Serialize(toSerialize, writer, settings);
return;
}
_ = settings.RequestResponseSerializer.TryGetJsonSerializerOptions(out var options);
JsonSerializer.Serialize(writer, toSerialize, options);
}
static VerifySerializerTestBase()
{
var settings = new ElasticsearchClientSettings();
settings.ApplyDomainSettings();
var client = new ElasticsearchClient(settings);
_requestResponseSerializer = client.RequestResponseSerializer;
_settings = client.ElasticsearchClientSettings;
}
public static void DeserializeParams <T>(ref Utf8JsonReader reader, IElasticsearchClientSettings settings)
{
if (settings.Experimental.UseSourceSerializerForScriptParameters)
{
Deserialize <T>(ref reader, settings);
return;
}
_ = settings.RequestResponseSerializer.TryGetJsonSerializerOptions(out var options);
JsonSerializer.Deserialize <T>(ref reader, options);
}
protected override void Serialize(Stream stream, IElasticsearchClientSettings settings, SerializationFormatting formatting)
{
var requestResponseSerializer = settings.RequestResponseSerializer;
var internalWriter = new Utf8JsonWriter(stream);
internalWriter.WriteStartObject();
internalWriter.WritePropertyName(Operation);
requestResponseSerializer.TryGetJsonSerializerOptions(out var options);
JsonSerializer.Serialize <BulkDeleteOperationDescriptor>(internalWriter, this, options);
internalWriter.WriteEndObject();
internalWriter.Flush();
}
protected override async Task SerializeAsync(Stream stream, IElasticsearchClientSettings settings, SerializationFormatting formatting, CancellationToken cancellationToken = default)
{
var requestResponseSerializer = settings.RequestResponseSerializer;
var internalWriter = new Utf8JsonWriter(stream);
internalWriter.WriteStartObject();
internalWriter.WritePropertyName(Operation);
requestResponseSerializer.TryGetJsonSerializerOptions(out var options);
JsonSerializer.Serialize <BulkDeleteOperationDescriptor>(internalWriter, this, options);
internalWriter.WriteEndObject();
await internalWriter.FlushAsync().ConfigureAwait(false);
}
protected InstanceSerializerTestBase(ElasticsearchClientSettings settings, bool applyDomainSettings = false)
{
if (applyDomainSettings)
{
settings.ApplyDomainSettings();
}
var client = new ElasticsearchClient(settings);
_requestResponseSerializer = client.RequestResponseSerializer;
_sourceSerializer = client.SourceSerializer;
_settings = client.ElasticsearchClientSettings;
}
protected override async Task SerializeAsync(Stream stream, IElasticsearchClientSettings settings)
{
BeforeSerialize(settings);
var internalWriter = new Utf8JsonWriter(stream);
SerializeOperationAction(settings, internalWriter);
internalWriter.Flush();
stream.WriteByte(_newline);
var body = GetBody();
await settings.RequestResponseSerializer.SerializeAsync(body, stream).ConfigureAwait(false);
await stream.FlushAsync().ConfigureAwait(false);
}
public Inferrer(IElasticsearchClientSettings elasticsearchClientSettings)
{
elasticsearchClientSettings.ThrowIfNull(nameof(elasticsearchClientSettings));
_elasticsearchClientSettings = elasticsearchClientSettings;
IdResolver = new IdResolver(elasticsearchClientSettings);
IndexNameResolver = new IndexNameResolver(elasticsearchClientSettings);
RelationNameResolver = new RelationNameResolver(elasticsearchClientSettings);
FieldResolver = new FieldResolver(elasticsearchClientSettings);
RoutingResolver = new RoutingResolver(elasticsearchClientSettings, IdResolver);
//CreateMultiHitDelegates =
// new ConcurrentDictionary<Type,
// Action<MultiGetResponseFormatter.MultiHitTuple, IJsonFormatterResolver, ICollection<IMultiGetHit<object>>>>();
//CreateSearchResponseDelegates =
// new ConcurrentDictionary<Type,
// Action<MultiSearchResponseFormatter.SearchHitTuple, IJsonFormatterResolver, IDictionary<string, IElasticsearchResponse>>>();
}
protected override void Serialize(Stream stream, IElasticsearchClientSettings settings, SerializationFormatting formatting = SerializationFormatting.None)
{
BeforeSerialize(settings);
var requestResponseSerializer = settings.RequestResponseSerializer;
var internalWriter = new Utf8JsonWriter(stream);
internalWriter.WriteStartObject();
internalWriter.WritePropertyName(Operation);
requestResponseSerializer.TryGetJsonSerializerOptions(out var options);
WriteOperation(internalWriter, options);
internalWriter.WriteEndObject();
internalWriter.Flush();
stream.WriteByte(_newline);
var body = GetBody();
settings.RequestResponseSerializer.Serialize(body, stream, formatting);
}
internal ReadOnlyIndexNameDictionary(Dictionary <IndexName, TValue> source, IElasticsearchClientSettings settings)
{
_settings = settings;
// This is an "optimised version" which doesn't cause a second dictionary to be allocated.
// Since we expect this to be used only for deserialisation, the keys received will already have been strings,
// so no further sanitisation is required.
//var backingDictionary = new Dictionary<IndexName, TValue>(source.Count);
if (source == null)
{
_backingDictionary = new Dictionary <IndexName, TValue>(0);
return;
}
//foreach (var key in source.Keys)
// backingDictionary[Sanitize(key)] = source[key];
_backingDictionary = source;
}
public void Serialize(Stream stream, IElasticsearchClientSettings settings, SerializationFormatting formatting = SerializationFormatting.None)
{
if (Operations is null)
{
return;
}
var index = Self.RouteValues.Get <IndexName>("index");
foreach (var op in Operations)
{
if (op is not IStreamSerializable serializable)
{
throw new InvalidOperationException("");
}
op.PrepareIndex(index);
serializable.Serialize(stream, settings, formatting);
stream.WriteByte((byte)'\n');
}
}
private void WriteBody(IElasticsearchClientSettings settings, Utf8JsonWriter writer, JsonSerializerOptions options)
{
if (_scriptAction is not null)
{
writer.WritePropertyName("script");
JsonSerializer.Serialize(writer, new InlineScriptDescriptor(_scriptAction), options);
}
if (_document is not null)
{
writer.WritePropertyName("doc");
SourceSerialisation.Serialize(_document, writer, settings.SourceSerializer);
}
if (_scriptedUpsert.HasValue)
{
writer.WritePropertyName("scripted_upsert");
JsonSerializer.Serialize(writer, _scriptedUpsert.Value, options);
}
if (_docAsUpsert.HasValue)
{
writer.WritePropertyName("doc_as_upsert");
JsonSerializer.Serialize(writer, _docAsUpsert.Value, options);
}
if (_upsert is not null)
{
writer.WritePropertyName("upsert");
SourceSerialisation.Serialize(_upsert, writer, settings.SourceSerializer);
}
if (_source is not null)
{
writer.WritePropertyName("_source");
JsonSerializer.Serialize(writer, Source, options);
}
}
protected override async Task SerializeAsync(Stream stream, IElasticsearchClientSettings settings, SerializationFormatting formatting, CancellationToken cancellationToken = default)
{
BeforeSerialize(settings);
var requestResponseSerializer = settings.RequestResponseSerializer;
var internalWriter = new Utf8JsonWriter(stream);
internalWriter.WriteStartObject();
internalWriter.WritePropertyName(Operation);
requestResponseSerializer.TryGetJsonSerializerOptions(out var options);
WriteOperation(internalWriter, options);
internalWriter.WriteEndObject();
internalWriter.Flush();
stream.WriteByte(_newline);
var body = GetBody();
await settings.SourceSerializer.SerializeAsync(body, stream, formatting).ConfigureAwait(false);
}
internal ConnectionSettingsAwareSerializer(
Serializer builtinSerializer,
IElasticsearchClientSettings connectionSettings,
Func <JsonSerializerSettings> jsonSerializerSettingsFactory,
Action <ConnectionSettingsAwareContractResolver> modifyContractResolver,
IEnumerable <JsonConverter> contractJsonConverters
)
{
JsonSerializerSettingsFactory = jsonSerializerSettingsFactory;
ModifyContractResolverCallback = modifyContractResolver;
ContractJsonConverters = contractJsonConverters ?? Enumerable.Empty <JsonConverter>();
ConnectionSettings = connectionSettings;
BuiltinSerializer = builtinSerializer;
Converters = new List <JsonConverter>
{
new HandleNestTypesOnSourceJsonConverter(BuiltinSerializer, connectionSettings.MemoryStreamFactory),
new TimeSpanToStringConverter(),
new StringEnumConverter()
};
_serializer = CreateSerializer(SerializationFormatting.Indented);
_collapsedSerializer = CreateSerializer(SerializationFormatting.None);
}
protected override void Serialize(Stream stream, IElasticsearchClientSettings settings, SerializationFormatting formatting)
{
var requestResponseSerializer = settings.RequestResponseSerializer;
var writer = new Utf8JsonWriter(stream);
writer.WriteStartObject();
writer.WritePropertyName(Operation);
requestResponseSerializer.TryGetJsonSerializerOptions(out var options);
JsonSerializer.Serialize <BulkUpdateOperationDescriptor <TDocument, TPartialDocument> >(writer, this, options);
writer.WriteEndObject();
writer.Flush();
stream.WriteByte(_newline);
var body = GetBody();
// In the simple path, we have a BulkUpdateBody we can simply serialise.
// Only if we have some deferred delegates to configure descriptors so we need to manually serialise the data.
if (body is not null)
{
settings.RequestResponseSerializer.Serialize(body, stream, formatting);
}
else
{
writer = new Utf8JsonWriter(stream);
writer.WriteStartObject();
WriteBody(settings, writer, options);
writer.WriteEndObject();
writer.Flush();
}
}
public MySecondCustomContractResolver(IElasticsearchClientSettings connectionSettings)
: base(connectionSettings)
{
}
protected override void Serialize(Utf8JsonWriter writer, JsonSerializerOptions options, IElasticsearchClientSettings settings) => JsonSerializer.Serialize(writer, Aggregations, options);
void ISelfTwoWaySerializable.Deserialize(ref Utf8JsonReader reader, JsonSerializerOptions options, IElasticsearchClientSettings settings)
{
while (reader.Read() && reader.TokenType != JsonTokenType.EndObject)
{
if (reader.TokenType == JsonTokenType.PropertyName)
{
if (reader.ValueTextEquals("lang"))
{
reader.Read();
var value = reader.GetString();
if (value is not null)
{
Language = value;
}
continue;
}
if (reader.ValueTextEquals("options"))
{
var value = JsonSerializer.Deserialize <Dictionary <string, string> >(ref reader, options);
if (value is not null)
{
Options = value;
}
continue;
}
if (reader.ValueTextEquals("source"))
{
reader.Read();
var value = reader.GetString();
if (value is not null)
{
Source = value;
}
continue;
}
if (reader.ValueTextEquals("params"))
{
var value = JsonSerializer.Deserialize <Dictionary <string, object> >(ref reader, options);
if (value is not null)
{
Params = value;
}
continue;
}
}
}
}
void ISelfTwoWaySerializable.Serialize(Utf8JsonWriter writer, JsonSerializerOptions options, IElasticsearchClientSettings settings)
{
writer.WriteStartObject();
if (Language is not null)
{
writer.WritePropertyName("lang");
JsonSerializer.Serialize(writer, Language, options);
}
if (Options is not null)
{
writer.WritePropertyName("options");
JsonSerializer.Serialize(writer, Options, options);
}
writer.WritePropertyName("source");
writer.WriteStringValue(Source);
if (Params is not null)
{
writer.WritePropertyName("params");
SourceSerialisation.SerializeParams(Params, writer, settings);
}
writer.WriteEndObject();
}
protected override void SerializeProperties(Utf8JsonWriter writer, JsonSerializerOptions options, IElasticsearchClientSettings settings)
{
if (PartialUpdate is not null)
{
writer.WritePropertyName("doc");
SourceSerialisation.Serialize(PartialUpdate, writer, settings.SourceSerializer);
}
if (Script is not null)
{
writer.WritePropertyName("script");
JsonSerializer.Serialize(writer, Script, options);
}
if (ScriptedUpsert.HasValue)
{
writer.WritePropertyName("scripted_upsert");
JsonSerializer.Serialize(writer, ScriptedUpsert.Value, options);
}
if (DocAsUpsert.HasValue)
{
writer.WritePropertyName("doc_as_upsert");
JsonSerializer.Serialize(writer, DocAsUpsert.Value, options);
}
if (Upsert is not null)
{
writer.WritePropertyName("upsert");
SourceSerialisation.Serialize(Upsert, writer, settings.SourceSerializer);
}
if (Source is not null)
{
writer.WritePropertyName("_source");
JsonSerializer.Serialize(writer, Source, options);
}
}
protected override void SerializeInternal(Utf8JsonWriter writer, JsonSerializerOptions options, IElasticsearchClientSettings settings)
{
}
public FieldConverter(IElasticsearchClientSettings settings) => _settings = settings;
void ISelfSerializable.Serialize(Utf8JsonWriter writer, JsonSerializerOptions options, IElasticsearchClientSettings settings)
{
writer.WriteStartObject();
if (IfSequenceNumber.HasValue)
{
writer.WritePropertyName("if_seq_no");
writer.WriteNumberValue(IfSequenceNumber.Value);
}
if (IfPrimaryTerm.HasValue)
{
writer.WritePropertyName("if_primary_term");
writer.WriteNumberValue(IfPrimaryTerm.Value);
}
SerializeProperties(writer, options, settings);
writer.WriteEndObject();
}
protected abstract void SerializeProperties(Utf8JsonWriter writer, JsonSerializerOptions options, IElasticsearchClientSettings settings);
