public async Task <IActionResult> SearchAsync([FromQuery] SearchTermDto term)
        {
            var result = await _searchService.SearchAsync(term.CustomerId);

            if (!result.IsSuccess)
            {
                return(NotFound($"Search for customer Id '{term.CustomerId}' is not found."));
            }

            return(Ok(result.SearchResults));
        }
        public async Task <List <SearchResultDto> > SearchAsync(string query)
        {
            var term = new SearchTermDto
            {
                Query = query
            };

            var response = await _httpClient.PostJsonAsync($"/api/search", term);

            response.EnsureSuccessStatusCode();

            return(await response.Content.ReadAsJsonAsync <List <SearchResultDto> >());
        }
Esempio n. 3
0
        public IHttpActionResult Search(SearchTermDto dto)
        {
            var productList = _userService.GetUserSearchResultList(dto.SearchTerm);

            return(Ok(productList));
        }
        public async Task <IActionResult> Search([FromBody] SearchTermDto term)
        {
            var query          = term.Query;
            var sessionResults = await _db.Sessions.Include(s => s.Track)
                                 .Include(s => s.SessionSpeakers)
                                 .ThenInclude(ss => ss.Speaker)
                                 .Where(s =>
                                        s.Title.Contains(query) ||
                                        s.Track.Name.Contains(query)
                                        )
                                 .ToListAsync();

            var speakerResults = await _db.Speakers.Include(s => s.SessionSpeakers)
                                 .ThenInclude(ss => ss.Session)
                                 .Where(s =>
                                        s.Name.Contains(query) ||
                                        s.Bio.Contains(query) ||
                                        s.WebSite.Contains(query)
                                        )
                                 .ToListAsync();

            var results = sessionResults.Select(s => new SearchResultDto
            {
                Type  = SearchResultType.Session,
                Value = JObject.FromObject(new SessionResponseDto
                {
                    ID           = s.ID,
                    Title        = s.Title,
                    Abstract     = s.Abstract,
                    ConferenceID = s.ConferenceID,
                    StartTime    = s.StartTime,
                    EndTime      = s.EndTime,
                    TrackId      = s.TrackId,
                    Track        = new ConferenceDTO.TrackDto
                    {
                        TrackID = s?.TrackId ?? 0,
                        Name    = s.Track?.Name
                    },
                    Speakers = s?.SessionSpeakers
                               .Select(ss => new ConferenceDTO.SpeakerDto
                    {
                        ID   = ss.SpeakerId,
                        Name = ss.Speaker.Name
                    })
                               .ToList()
                })
            })
                          .Concat(speakerResults.Select(s => new SearchResultDto
            {
                Type  = SearchResultType.Speaker,
                Value = JObject.FromObject(new SpeakerResponseDto
                {
                    ID       = s.ID,
                    Name     = s.Name,
                    Bio      = s.Bio,
                    WebSite  = s.WebSite,
                    Sessions = s.SessionSpeakers?
                               .Select(ss =>
                                       new ConferenceDTO.SessionDto
                    {
                        ID    = ss.SessionId,
                        Title = ss.Session.Title
                    })
                               .ToList()
                })
            }));

            return(Ok(results));
        }