Skip to content

Support aliased properties #6621

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Jul 27, 2022
Merged

Support aliased properties #6621

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
42d44d5
Supported aliased properties on requests
stevejgordon Jul 27, 2022
607dace
Support aliased properties for classes
stevejgordon Jul 27, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
385 changes: 385 additions & 0 deletions src/Elastic.Clients.Elasticsearch/_Generated/Api/AsyncSearch/AsyncSearchSubmitRequest.g.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -124,6 +124,391 @@ public sealed class AsyncSearchSubmitRequestParameters : RequestParameters<Async
public string? QueryLuceneSyntax { get => Q<string?>("q"); set => Q("q", value); }
}

internal sealed class AsyncSearchSubmitRequestConverter : JsonConverter<AsyncSearchSubmitRequest>
{
public override AsyncSearchSubmitRequest Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
if (reader.TokenType != JsonTokenType.StartObject)
throw new JsonException("Unexpected JSON detected.");
var variant = new AsyncSearchSubmitRequest();
while (reader.Read() && reader.TokenType != JsonTokenType.EndObject)
{
if (reader.TokenType == JsonTokenType.PropertyName)
{
var property = reader.GetString();
if (property == "aggregations" || property == "aggs")
{
variant.Aggregations = JsonSerializer.Deserialize<Elastic.Clients.Elasticsearch.Aggregations.AggregationDictionary?>(ref reader, options);
continue;
}

if (property == "collapse")
{
variant.Collapse = JsonSerializer.Deserialize<Elastic.Clients.Elasticsearch.FieldCollapse?>(ref reader, options);
continue;
}

if (property == "explain")
{
variant.Explain = JsonSerializer.Deserialize<bool?>(ref reader, options);
continue;
}

if (property == "from")
{
variant.From = JsonSerializer.Deserialize<int?>(ref reader, options);
continue;
}

if (property == "highlight")
{
variant.Highlight = JsonSerializer.Deserialize<Elastic.Clients.Elasticsearch.Highlight?>(ref reader, options);
continue;
}

if (property == "track_total_hits")
{
variant.TrackTotalHits = JsonSerializer.Deserialize<Elastic.Clients.Elasticsearch.TrackHits?>(ref reader, options);
continue;
}

if (property == "indices_boost")
{
variant.IndicesBoost = JsonSerializer.Deserialize<IEnumerable<Dictionary<Elastic.Clients.Elasticsearch.IndexName, double>>?>(ref reader, options);
continue;
}

if (property == "docvalue_fields")
{
variant.DocvalueFields = JsonSerializer.Deserialize<IEnumerable<Elastic.Clients.Elasticsearch.QueryDsl.FieldAndFormat>?>(ref reader, options);
continue;
}

if (property == "min_score")
{
variant.MinScore = JsonSerializer.Deserialize<double?>(ref reader, options);
continue;
}

if (property == "post_filter")
{
variant.PostFilter = JsonSerializer.Deserialize<Elastic.Clients.Elasticsearch.QueryDsl.QueryContainer?>(ref reader, options);
continue;
}

if (property == "profile")
{
variant.Profile = JsonSerializer.Deserialize<bool?>(ref reader, options);
continue;
}

if (property == "query")
{
variant.Query = JsonSerializer.Deserialize<Elastic.Clients.Elasticsearch.QueryDsl.QueryContainer?>(ref reader, options);
continue;
}

if (property == "rescore")
{
variant.Rescore = JsonSerializer.Deserialize<IEnumerable<Elastic.Clients.Elasticsearch.Rescore>?>(ref reader, options);
continue;
}

if (property == "script_fields")
{
variant.ScriptFields = JsonSerializer.Deserialize<Dictionary<string, Elastic.Clients.Elasticsearch.ScriptField>?>(ref reader, options);
continue;
}

if (property == "search_after")
{
variant.SearchAfter = JsonSerializer.Deserialize<IEnumerable<object>?>(ref reader, options);
continue;
}

if (property == "size")
{
variant.Size = JsonSerializer.Deserialize<int?>(ref reader, options);
continue;
}

if (property == "slice")
{
variant.Slice = JsonSerializer.Deserialize<Elastic.Clients.Elasticsearch.SlicedScroll?>(ref reader, options);
continue;
}

if (property == "sort")
{
variant.Sort = JsonSerializer.Deserialize<IEnumerable<Elastic.Clients.Elasticsearch.SortCombinations>?>(ref reader, options);
continue;
}

if (property == "_source")
{
variant.Source = JsonSerializer.Deserialize<Elastic.Clients.Elasticsearch.SourceConfig?>(ref reader, options);
continue;
}

if (property == "fields")
{
variant.Fields = JsonSerializer.Deserialize<IEnumerable<Elastic.Clients.Elasticsearch.QueryDsl.FieldAndFormat>?>(ref reader, options);
continue;
}

if (property == "suggest")
{
variant.Suggest = JsonSerializer.Deserialize<Elastic.Clients.Elasticsearch.Suggester?>(ref reader, options);
continue;
}

if (property == "terminate_after")
{
variant.TerminateAfter = JsonSerializer.Deserialize<long?>(ref reader, options);
continue;
}

if (property == "timeout")
{
variant.Timeout = JsonSerializer.Deserialize<string?>(ref reader, options);
continue;
}

if (property == "track_scores")
{
variant.TrackScores = JsonSerializer.Deserialize<bool?>(ref reader, options);
continue;
}

if (property == "version")
{
variant.Version = JsonSerializer.Deserialize<bool?>(ref reader, options);
continue;
}

if (property == "seq_no_primary_term")
{
variant.SeqNoPrimaryTerm = JsonSerializer.Deserialize<bool?>(ref reader, options);
continue;
}

if (property == "stored_fields")
{
variant.StoredFields = JsonSerializer.Deserialize<Elastic.Clients.Elasticsearch.Fields?>(ref reader, options);
continue;
}

if (property == "pit")
{
variant.Pit = JsonSerializer.Deserialize<Elastic.Clients.Elasticsearch.PointInTimeReference?>(ref reader, options);
continue;
}

if (property == "runtime_mappings")
{
variant.RuntimeMappings = JsonSerializer.Deserialize<Dictionary<Elastic.Clients.Elasticsearch.Field, IEnumerable<Elastic.Clients.Elasticsearch.Mapping.RuntimeField>>?>(ref reader, options);
continue;
}

if (property == "stats")
{
variant.Stats = JsonSerializer.Deserialize<IEnumerable<string>?>(ref reader, options);
continue;
}
}
}

return variant;
}

public override void Write(Utf8JsonWriter writer, AsyncSearchSubmitRequest value, JsonSerializerOptions options)
{
writer.WriteStartObject();
if (value.Aggregations is not null)
{
writer.WritePropertyName("aggregations");
JsonSerializer.Serialize(writer, value.Aggregations, options);
}

if (value.Collapse is not null)
{
writer.WritePropertyName("collapse");
JsonSerializer.Serialize(writer, value.Collapse, options);
}

if (value.Explain.HasValue)
{
writer.WritePropertyName("explain");
writer.WriteBooleanValue(value.Explain.Value);
}

if (value.From.HasValue)
{
writer.WritePropertyName("from");
writer.WriteNumberValue(value.From.Value);
}

if (value.Highlight is not null)
{
writer.WritePropertyName("highlight");
JsonSerializer.Serialize(writer, value.Highlight, options);
}

if (value.TrackTotalHits is not null)
{
writer.WritePropertyName("track_total_hits");
JsonSerializer.Serialize(writer, value.TrackTotalHits, options);
}

if (value.IndicesBoost is not null)
{
writer.WritePropertyName("indices_boost");
JsonSerializer.Serialize(writer, value.IndicesBoost, options);
}

if (value.DocvalueFields is not null)
{
writer.WritePropertyName("docvalue_fields");
JsonSerializer.Serialize(writer, value.DocvalueFields, options);
}

if (value.MinScore.HasValue)
{
writer.WritePropertyName("min_score");
writer.WriteNumberValue(value.MinScore.Value);
}

if (value.PostFilter is not null)
{
writer.WritePropertyName("post_filter");
JsonSerializer.Serialize(writer, value.PostFilter, options);
}

if (value.Profile.HasValue)
{
writer.WritePropertyName("profile");
writer.WriteBooleanValue(value.Profile.Value);
}

if (value.Query is not null)
{
writer.WritePropertyName("query");
JsonSerializer.Serialize(writer, value.Query, options);
}

if (value.Rescore is not null)
{
writer.WritePropertyName("rescore");
JsonSerializer.Serialize(writer, value.Rescore, options);
}

if (value.ScriptFields is not null)
{
writer.WritePropertyName("script_fields");
JsonSerializer.Serialize(writer, value.ScriptFields, options);
}

if (value.SearchAfter is not null)
{
writer.WritePropertyName("search_after");
JsonSerializer.Serialize(writer, value.SearchAfter, options);
}

if (value.Size.HasValue)
{
writer.WritePropertyName("size");
writer.WriteNumberValue(value.Size.Value);
}

if (value.Slice is not null)
{
writer.WritePropertyName("slice");
JsonSerializer.Serialize(writer, value.Slice, options);
}

if (value.Sort is not null)
{
writer.WritePropertyName("sort");
JsonSerializer.Serialize(writer, value.Sort, options);
}

if (value.Source is not null)
{
writer.WritePropertyName("_source");
JsonSerializer.Serialize(writer, value.Source, options);
}

if (value.Fields is not null)
{
writer.WritePropertyName("fields");
JsonSerializer.Serialize(writer, value.Fields, options);
}

if (value.Suggest is not null)
{
writer.WritePropertyName("suggest");
JsonSerializer.Serialize(writer, value.Suggest, options);
}

if (value.TerminateAfter.HasValue)
{
writer.WritePropertyName("terminate_after");
writer.WriteNumberValue(value.TerminateAfter.Value);
}

if (!string.IsNullOrEmpty(value.Timeout))
{
writer.WritePropertyName("timeout");
writer.WriteStringValue(value.Timeout);
}

if (value.TrackScores.HasValue)
{
writer.WritePropertyName("track_scores");
writer.WriteBooleanValue(value.TrackScores.Value);
}

if (value.Version.HasValue)
{
writer.WritePropertyName("version");
writer.WriteBooleanValue(value.Version.Value);
}

if (value.SeqNoPrimaryTerm.HasValue)
{
writer.WritePropertyName("seq_no_primary_term");
writer.WriteBooleanValue(value.SeqNoPrimaryTerm.Value);
}

if (value.StoredFields is not null)
{
writer.WritePropertyName("stored_fields");
JsonSerializer.Serialize(writer, value.StoredFields, options);
}

if (value.Pit is not null)
{
writer.WritePropertyName("pit");
JsonSerializer.Serialize(writer, value.Pit, options);
}

if (value.RuntimeMappings is not null)
{
writer.WritePropertyName("runtime_mappings");
JsonSerializer.Serialize(writer, value.RuntimeMappings, options);
}

if (value.Stats is not null)
{
writer.WritePropertyName("stats");
JsonSerializer.Serialize(writer, value.Stats, options);
}

writer.WriteEndObject();
}
}

[JsonConverter(typeof(AsyncSearchSubmitRequestConverter))]
public partial class AsyncSearchSubmitRequest : PlainRequestBase<AsyncSearchSubmitRequestParameters>
{
public AsyncSearchSubmitRequest()
Expand Down
Loading