public async Task SearchBooksAsync()

in supporting-blog-content/esre-with-blazor/elastic-blazor/Services/ElasticsearchService.cs [177:268]
51 lines of code
4 McCabe index (conditional complexity)

        public async Task<ElasticResponse> SearchBooksAsync(
            string searchTerm,
            Dictionary<string, List<string>> selectedFacets
        )
        {
            try
            {
                _logger.LogInformation($"Performing search for: {searchTerm}");

                var retrieverQuery = BuildHybridQuery(searchTerm, selectedFacets);
                var multiMatchQuery = BuildMultiMatchQuery(searchTerm, selectedFacets);
                var semanticQuery = BuildSemanticQuery(searchTerm, selectedFacets);
                
                /**
                 * * Hybrid Search
                 */
                var response = await _client.SearchAsync<BookDoc>(s =>
                    s.Index("elastic-blazor-books")
                        .Retriever(retrieverQuery)
                        .Aggregations(aggs =>
                            aggs.Add("Authors", agg => agg.Terms(t => t.Field(p => p.Authors)))
                                .Add(
                                    "Categories",
                                    agg => agg.Terms(t => t.Field(p => p.Categories))
                                )
                                .Add("Status", agg => agg.Terms(t => t.Field(p => p.Status)))
                        )
                );

                /**
                 * * MultiMatch Search
                 */
                // var response = await _client.SearchAsync<BookDoc>(s =>
                //     s.Index("elastic-blazor-books")
                //         .Query(multiMatchQuery)
                //         .Aggregations(aggs =>
                //             aggs.Add("Authors", agg => agg.Terms(t => t.Field(p => p.Authors)))
                //                 .Add(
                //                     "Categories",
                //                     agg => agg.Terms(t => t.Field(p => p.Categories))
                //                 )
                //                 .Add("Status", agg => agg.Terms(t => t.Field(p => p.Status)))
                //         )
                // );

                /**
                 * * Semantic Search
                 */
                // var response = await _client.SearchAsync<BookDoc>(s =>
                //     s.Index("elastic-blazor-books")
                //         .Query(semanticQuery)
                //         .Aggregations(aggs =>
                //             aggs.Add("Authors", agg => agg.Terms(t => t.Field(p => p.Authors)))
                //                 .Add(
                //                     "Categories",
                //                     agg => agg.Terms(t => t.Field(p => p.Categories))
                //                 )
                //                 .Add("Status", agg => agg.Terms(t => t.Field(p => p.Status)))
                //         )
                // );

                if (response.IsValidResponse)
                {
                    _logger.LogInformation($"Found {response.Documents.Count} documents");

                    var hits = response.Total;
                    var facets =
                        response.Aggregations != null
                            ? FormatFacets(response.Aggregations)
                            : new Dictionary<string, Dictionary<string, long>>();

                    var elasticResponse = new ElasticResponse
                    {
                        TotalHits = hits,
                        Documents = response.Documents.ToList(),
                        Facets = facets,
                    };

                    return elasticResponse;
                }
                else
                {
                    _logger.LogWarning($"Invalid response: {response.DebugInformation}");
                    return new ElasticResponse();
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error performing search");
                return new ElasticResponse();
            }
        }