public async Task <SearchResultDto> search(string q, SearchType t, int p)
{
var url = "";
if (t == SearchType.repos)
{
url = "https://api.github.com/search/repositories?q=" + q + "&per_page=10&page=" + p;
}
else
{
url = "https://api.github.com/search/users?q=" + q + "&per_page=10&page=" + p;
}
var client = _clientFactory.CreateClient();
client.DefaultRequestHeaders.UserAgent.TryParseAdd("hos4am");
var request = new HttpRequestMessage(HttpMethod.Get, url);
var response = await client.SendAsync(request);
if (response.IsSuccessStatusCode)
{
var result = response.Content.ReadAsStringAsync().Result;
SearchResultDto obj = Newtonsoft.Json.JsonConvert.DeserializeObject <SearchResultDto>(result);
return(obj);
}
else
{
return(null);
}
}
private void PopulateTreeWithTypes(SearchResultDto <ContentType> contentTypes)
{
if (contentTypes != null)
{
treeViewLC.BeginUpdate();
var rootNode = new TreeNode("Content Types");
treeViewLC.Nodes.Add(rootNode);
foreach (var doc in contentTypes.Documents)
{
var node = new TreeNode(doc.Name);
rootNode.Nodes.Add(node);
var fieldsNode = new TreeNode("Fields");
foreach (var field in doc.Fields)
{
fieldsNode.Nodes.Add(JsonConvert.SerializeObject(field, Formatting.Indented));
}
doc.Fields = null;
doc.Properties = null;
node.Nodes.Add(JsonConvert.SerializeObject(doc, Formatting.Indented));
node.Nodes.Add(fieldsNode);
//UNDONE: add content type properties to each new node
}
treeViewLC.EndUpdate();
}
}
private IHttpActionResult Search(string username, ISearchingCriterion <Offer>[] criteria, SortType sortType, SortBy sortBy)
{
using (var context = _provider.GetNewContext())
{
if (context is DbContext)
{
(context as DbContext).Configuration.ProxyCreationEnabled = false;
}
if (string.IsNullOrEmpty(username))
{
return(NotFound());
}
User u = context.Users.FirstOrDefault(us => us.Username.Equals(username));
if (u == null)
{
return(NotFound());
}
IQueryable <Offer> offers = context.Offers.Where(o => o.VendorId != u.Id).Where(o => !o.IsBooked);
offers = criteria.Aggregate(offers, (current, criterion) => current.Where(criterion.SelectableExpression));
offers = offers.Take(20).OrderBy(sortType, sortBy);
List <Offer> list = offers.ToList();
SearchResultDto dto = new SearchResultDto()
{
Offers = list
};
return(Ok(dto));
}
}
public async Task <IActionResult> Keyword(string pPageToken, string pSearchKeyword)
{
if (string.IsNullOrEmpty(pPageToken))
{
return(ErrorProblem());
}
if (string.IsNullOrEmpty(pSearchKeyword))
{
return(ErrorProblem());
}
if (pSearchKeyword.Length < 2)
{
return(View(new SearchResultDto()));
}
AbstractSearchResultDto songsList = new SearchResultDto();
songsList = await _youtubeSearch.SearchListByKeyword(pSearchKeyword, pPageToken);
songsList.TagsList = await _tagEntity.GetRandomTags();
return(View(songsList));
}
public async Task <ISearchResultDto> GetSearchResult(string apiKey)
{
SearchResultDto mySearchObject = new SearchResultDto();
mySearchObject = await apiClient.GetAsync <SearchResultDto>(omdbUrl + apiKey);
return(mySearchObject);
}
public async Task OnSearchClicked()
{
if (string.IsNullOrWhiteSpace(Query))
{
return;
}
if (Query.Length > 100)
{
return;
}
IsSearching = true;
bool isError = false;
SearchResultDto result = null;
try
{
result = await ApiClient.Search(Query);
}
catch (Exception e)
{
Logger.LogError(e, "Search exception; Query: {Query}", Query);
isError = true;
}
Query = null;
IsSearching = false;
if (isError || result == null)
{
return;
}
string url = "/search/error?";
switch (result.Type)
{
case SearchResultType.AddressHash:
url = $"/address/{result.Id}";
break;
case SearchResultType.BlockHash:
url = $"/block/{result.Id}";
break;
case SearchResultType.BlockNumber:
url = $"/block-height/{result.Id}";
break;
case SearchResultType.TransactionHash:
url = $"/transaction/{result.Id}";
break;
}
UriHelper.NavigateTo(url);
}
public SearchPageViewModel(string keyword, SearchResultDto searchResult, Uri requestedUrl, LanguageDto language)
: base(requestedUrl, language)
{
Keyword = keyword;
Items = searchResult.Records;
TotalCount = searchResult.TotalRecords;
PaginationViewModel = new PaginationViewModel(TotalCount, CurrentPage, WebContext.Current.MaxPageSize, WebContext.Current.PagerWindowSize);
}
private SearchResultModel CreateSearchResultModel(SearchResultDto search)
{
var model = new SearchResultModel
{
Id = search.Id,
Rank = search.Rank,
Body = search.Body
};
return(model);
}
public async Task <IActionResult> OnGetLatestChangesAsync()
{
var qry = new GetLatestArticlesQuery(10);
var results = await _mediator.Send(qry);
SearchResult = _mapper.Map <SearchResultDto <ArticleSummary> >(results);
SearchResult.ResultsPerPage = 11;
SearchResult.CurrentPage = 1;
return(Page());
}
public async Task <SearchResultDto> Search(string query)
{
string url = $"/v1/search?query={query}";
using HttpResponseMessage response = await _client.GetAsync(url).ConfigureAwait(false);
response.EnsureSuccessStatusCode();
SearchResultDto result = await response.Content.ReadAsAsync <SearchResultDto>().ConfigureAwait(false);
return(result);
}
public async Task <IActionResult> OnGetAsync([FromQuery(Name = "Query")] string query = "", [FromQuery(Name = "PageNumber")] int pageNumber = 1)
{
if (string.IsNullOrEmpty(query))
{
return(Page());
}
var qry = new SearchArticlesQuery(query, pageNumber, ResultsPerPage);
var result = await _mediator.Send(qry);
SearchResult = _mapper.Map <SearchResultDto <ArticleSummary> >(result);
return(Page());
}
public ActionResult GetSearchedServices([FromQuery] string name, [FromQuery] double lat, [FromQuery] double lng)
{
SearchServiceDto sSDto = new SearchServiceDto {
Name = name, Position = new Position {
Lat = lat, Lng = lng
}
};
SearchResultDto searchResult = new SearchResultDto();
Coordinate origin = new Coordinate(sSDto.Position.Lat, sSDto.Position.Lng);
List <Result> serviceSearchResult = new List <Result>();
int totalServiceFound = 0;
int totalSearchedServices = 0;
foreach (var service in _services)
{
Coordinate destination = new Coordinate(service.Position.Lat, service.Position.Lng);
totalSearchedServices++;
if (service.Name.ToUpper().Contains(name.ToUpper()) || name.ToUpper() == service.Name.ToUpper())
{
Result result = new Result();
result.Service = service;
totalServiceFound++;
if (name.ToUpper() == service.Name.ToUpper())
{
result.Score += 10;
}
if (service.Name.ToUpper().Contains(name.ToUpper()))
{
result.Score += 5;
}
result.Distance = GeoCalculator.GetDistance(origin, destination, 15, DistanceUnit.Kilometers);
serviceSearchResult.Add(result);
}
}
searchResult.TotalHits = totalServiceFound;
searchResult.TotalDocuments = totalSearchedServices;
searchResult.Results = serviceSearchResult;
return(Ok(searchResult));
}
public static SearchResultModel FromDto(SearchResultDto dto)
{
if (dto == null)
{
return(null);
}
return(new SearchResultModel
{
citizens = dto.Citizens?.Select(a => CitizenModel.FromDto(a)).ToArray(),
is_successed = dto.IsSuccessed,
message = dto.Message,
error = dto.Error
});
}
public ActionResult <SearchResultDto> Get(string q)
{
var result = new SearchResultDto();
if (string.IsNullOrWhiteSpace(q))
{
return(Ok(result));
}
result.Kanjis = FindSimilarKanjis(q);
result.Homonyms = FindHomonyms(q);
result.Synonyms = FindSynonyms(q);
return(Ok(result));
}
public static SearchResultDto ToDto(this ISearchResponse <WebsiteInfo> searchResponse, SearchPagination pagination, SearchContentDTO searchedContent)
{
SearchResultDto result = new SearchResultDto
{
SearchHits = searchResponse.Hits.ToDtos(),
SearchMetadata = new SearchMetadataDto
{
Took = searchResponse.Took,
Total = searchResponse.Total,
SearchedContent = searchedContent
},
SearchPagination = pagination
};
return(result);
}
public SearchResultDto Execute(SearchDto dto)
{
SearchResultDto result = new SearchResultDto {
Status = true, Message = Messages.Success,
};
result.Object = new SearchObject
{
Expense = unit.Expense.Search(dto),
Feedback = unit.Feedback.Search(dto),
Lead = unit.Lead.Search(dto),
Order = unit.Order.Search(dto),
Party = unit.Party.Search(dto)
};
return(result);
}
private SearchResultModel CreateSearchResultModel(SearchResultDto search)
{
var model = new SearchResultModel
{
Id = search.Id,
Title = search.Title,
PostType = search.PostType,
CreationDate = search.CreationDate,
AcceptedAnswerId = search.AcceptedAnswerId,
Rank = search.Rank,
Body = search.Body,
ParentID = search.ParentID,
Score = search.Score
};
return(model);
}
public async Task When_execution_always_fails_it_should_try_till_max_try_count()
{
var tryCount = 0;
var maxTry = 5;
var result = await SearchExecutor.Run((page) =>
{
tryCount++;
SearchResultDto searchResult = null;
return(Task.FromResult(searchResult));
},
maxTry,
5,
TimeSpan.FromMilliseconds(5));
Assert.AreEqual(maxTry, tryCount);
Assert.IsEmpty(result);
}
private void PopulateTreeWithItems(SearchResultDto <ContentItem> contentItems)
{
if (contentItems != null)
{
treeViewLC.BeginUpdate();
var rootNode = new TreeNode("Content Items");
treeViewLC.Nodes.Add(rootNode);
foreach (var doc in contentItems.Documents)
{
var node = new TreeNode(doc.ContentTypeName + ": " + doc.Name);
rootNode.Nodes.Add(node);
node.Nodes.Add(JsonConvert.SerializeObject(doc, Formatting.Indented));
//UNDONE: add content item properties to each new node
}
treeViewLC.EndUpdate();
}
}
/// <summary>
/// Возвращает результат поиска в виде объекта для передачи
/// </summary>
/// <param name="query">Строка поиска</param>
/// <param name="page">Необходимая страница</param>
/// <returns></returns>
public SearchResultDto SearchRow(string query, int page)
{
if (page > 0)
{
SearchResultDto result;
using (db = new MyDbContext())
{
var records = GetFileRowsNoTrackingQuery().Where(x => x.Text.Contains(query));
var recordsCount = records.Count();
var pageSize = 20;
var recordsToSkip = pageSize * (page - 1);
var searchResult = records.OrderBy(x => x.Text)
.Skip(recordsToSkip)
.Take(pageSize)
.OrderBy(x => x.Number)
.Select(x => new FileRowModel
{
RowNumber = x.Number,
RowText = x.Text
})
.ToList();
result = new SearchResultDto
{
ResultsOnPage = searchResult,
ResultsCount = recordsCount,
CurrentPage = page,
PagesCount = (int)Math.Ceiling((double)recordsCount / pageSize)
};
}
return(result);
}
else
{
throw new ArgumentOutOfRangeException("page");
}
}
public void SearchTvShowAsync()
{
const string query = "TvShowTitle";
var resultDto = new SearchResultDto <string, SearchTv>()
{
CurrentCollection = new List <string>
{
"True Detective"
},
QueryCollection = new List <SearchTv>()
};
_fixture.MockService.Setup(_ => _.SearchTvShowAsync(query)).ReturnsAsync(resultDto);
var controller = new TvShowController(_fixture.MockService.Object, _fixture.Mapper);
var result = controller.SearchTvShowAsync(query);
var viewResult = Assert.IsType <PartialViewResult>(result.Result);
Assert.IsType <SearchResultViewModel <string, SearchTv> >(viewResult.Model);
}
public void SearchMovieAsyncTest()
{
const string query = "movie-title";
var resultDto = new SearchResultDto <int, SearchMovie>
{
CurrentCollection = new List <int>
{
1, 2
},
QueryCollection = new List <SearchMovie>()
};
_fixture.MockService.Setup(_ => _.SearchMovieAsync(query)).ReturnsAsync(resultDto);
var controller = new MovieController(_fixture.MockService.Object, _fixture.Mapper);
var result = controller.SearchMovieAsync(query);
var viewResult = Assert.IsType <PartialViewResult>(result.Result);
Assert.IsType <SearchResultViewModel <int, SearchMovie> >(viewResult.Model);
}
public async Task AddResultToDbAsync(SearchResultDto searchResult)
{
await _context.AddAsync(searchResult);
await SaveChangesAsync();
}
/// <summary>
/// Returns the SearchResultDto containing the data of the given SearchResult
/// </summary>
/// <param name="searchResult">SearchResult to convert</param>
/// <returns>Converted SearchResultDto</returns>
public static SearchResultDto ConvertSearchResultToDto(SearchResult searchResult)
{
var resultDto = new SearchResultDto();
resultDto.Customers = new List<CustomerDto>();
resultDto.Bookings = new List<BookingDto>();
if (searchResult.Customers != null)
{
resultDto.Customers = searchResult.Customers.ConvertAll(ConvertCustomerToDto);
}
if (searchResult.Bookings != null)
{
resultDto.Bookings = searchResult.Bookings.ConvertAll(ConvertBookingToDto);
}
return resultDto;
}
public async Task <IList <SearchResultDto> > Search(string searchText)
{
//This is here just for convenience to avoid create FTS indexes manually
if (!_ftsEngine.DoIndexesExist())
{
await CreateFtsIndexesAsync();
}
var result = new List <SearchResultDto>();
var restaurants = _searchManager.SearchRestaurants(searchText).OrderByDescending(x => x.Value.Count).ThenBy(x => x.Key.Rank);
var foundCategories = _searchManager.SearchCategories(searchText);
//TODO: Automapper could be used
foreach (KeyValuePair <Restaurant, List <MenuItem> > keyValuePair in restaurants)
{
var resultDto = new SearchResultDto
{
Id = keyValuePair.Key.Id,
LogoPath = keyValuePair.Key.LogoPath,
Rank = keyValuePair.Key.Rank,
RestaurantName = keyValuePair.Key.Name,
Suburb = keyValuePair.Key.Suburb
};
result.Add(resultDto);
foreach (MenuItem menuItem in keyValuePair.Value)
{
var category = foundCategories.FirstOrDefault(x => x.Name == menuItem.Category.Name);
var menuItemDto = new MenuItemDto
{
Id = menuItem.Id,
Name = menuItem.Name,
Price = menuItem.Price
};
if (category != null)
{
var categoryDto = resultDto.CategoryGroups.FirstOrDefault(x => x.Id == category.Id);
if (categoryDto == null)
{
categoryDto = new CategoryGroupDto
{
Name = category.Name,
Id = category.Id
};
resultDto.CategoryGroups.Add(categoryDto);
}
categoryDto.MenuItems.Add(menuItemDto);
}
else
{
resultDto.MenuItems.Add(menuItemDto);
}
}
}
return(result);
}
