Migration issues Templates and Dynamic queries about elasticsearch-net HOT 5 OPEN

        private static Action<QueryDescriptor<MySearchModel>> BuildQuery([NotNull] MyRequest request)
        {
            var musts = new List<Action<QueryDescriptor<MySearchModel>>>();
            var mustNots = new List<Action<QueryDescriptor<MySearchModel>>>();
            var shoulds = new List<Action<QueryDescriptor<MySearchModel>>>();

            if (request.TagIds?.Any() ?? false)
            {
                musts
                    .Add(m => m
                        .Terms(t => t
                            .Field(f => f.Tags)
                            .Terms(new TermsQueryField(request.TagIds.Select(x => FieldValue.Long(x)).ToArray()))
                        )
                    );
            }

            if (request.DocumentTypeId != null && request.DocumentTypeId != 0)
            {
                musts
                    .Add(m => m
                        .Term(t => t
                            .Field("docTypeId")
                            .Value(FieldValue.Long(request.DocumentTypeId ?? 0))
                        )
                    );
            }

            mustNots
                .Add(m => m
                    .Term(t => t
                        .Field(f => f.HideInSearchResults)
                        .Value(FieldValue.Boolean(true))
                    )
                );

            if (request.ExcludedDocumentTypeIds != null && (request.ExcludedDocumentTypeIds?.Any() ?? false))
            {
                mustNots
                    .Add(m => m
                        .Terms(t => t
                            .Field("docTypeId")
                            .Terms(new TermsQueryField(request.ExcludedDocumentTypeIds.Select(x => FieldValue.Long(x)).ToArray()))
                        )
                    );
            }
            if (request.ExcludedPageIds != null && (request.ExcludedPageIds?.Any() ?? false))
            {
                mustNots
                    .Add(m => m
                        .Terms(t => t
                            .Field("id")
                            .Terms(new TermsQueryField(request.ExcludedPageIds.Select(x => FieldValue.Long(x)).ToArray()))
                        )
                    );
            }

            if (request.PrimaryTagId.HasValue && request.PrimaryTagId != 0)
            {
                shoulds
                    .Add(s => s
                        .Term(t => t
                            .Field("primaryTagId")
                            .Value(FieldValue.Long(request.PrimaryTagId.Value))
                        )
                    );
            }

            return query => query
                .Bool(b => b
                    .Must(musts.ToArray())
                    .MustNot(mustNots.ToArray())
                    .Should(shoulds.ToArray())
                );
        }

                Action<SearchRequestDescriptor<MySearchModel>> searchRequest = s => s
                                        .Index("my-index")
                                        .Query(BuildQuery(request))
                                        .Sort(s => s.Field(f => f.UpdatedOn, fs => fs.Order(SortOrder.Desc)))
                                        .From(0)
                                        .Size(20);

        private static Action<SortOptionsDescriptor<MySearchModel>>[] BuildSort(string sortOption)
        {
            return sortOption.ToLower() switch
            {
                "sort2" => new Action<SortOptionsDescriptor<MySearchModel>>[]
                    {
                        s => s.Field(f => f.MyField1, fs => fs.Order(SortOrder.Asc)),
                        s => s.Field(f => f.MyField2, fs => fs.Order(SortOrder.Desc)),
                    },
                "sort3" => new Action<SortOptionsDescriptor<MySearchModel>>[]
                    {
                        s => s.Field(f => f.MyField3, fs => fs.Order(SortOrder.Desc)),
                        s => s.Score(new ScoreSort() { Order = SortOrder.Desc })
                    },
                _ => new Action<SortOptionsDescriptor<MySearchModel>>[]
                    {
                        s => s.Field(f => f.MyField4, fs => fs.Order(SortOrder.Desc)),
                        s => s.Field(f => f.Dates.FirstOrDefault().StartDate, fs => fs.Order(SortOrder.Asc)),
                        s => s.Field(f => f.Dates.FirstOrDefault().EndDate, fs => fs.Order(SortOrder.Asc)),
                    },
            };
        }

                Action<SearchRequestDescriptor<MySearchModel>> searchRequest = s => s
                                        .Index("my-index")
                                        .Query(BuildQuery(request))
                                        .Sort(BuildSort(sortOption))
                                        .From(0)
                                        .Size(20);