public async Task <IActionResult> Index(string search)
{
try
{
//Vymodellens värde kommer från en söksträng som matas in i OMDb, som sedan spottar ut en lista med filmer som matchar sökordet.
//Listan som kommer ut är informationsmässigt relativt bristfällig.
//För att få mer information kring filmerna i söklistan kör vi den genom OMDB ytterligare en gång, med en sökning per film.
// Den listan används i vymodellen för att presentera all den information som vi önskar presentera.
SearchResultViewModel viewModel = new SearchResultViewModel(await omdbrepo.GetMovieListOMDB(await omdbrepo.GetSearchResultsOMDB(search)));
return(View(viewModel));
}
//Ifall något går fel så skickas användaren till Error vyn.
catch (Exception)
{
return(RedirectToAction("Index", "Error"));
}
}
public ActionResult Index(int?page)
{
var pageNumber = page ?? 1;
var objectsPerPage = Config.PageSize;
var startIndex = (pageNumber - 1) * objectsPerPage;
var searchResult = _orederRepository.Get(new SearchParamsOrder(startIndex, objectsPerPage)
{
SortByDate = true
});
var viewModel = SearchResultViewModel <Pyramid.Entity.Order> .CreateFromSearchResult(searchResult, i => i, 10);
return(View(viewModel));
}
public IActionResult Search(string keyword, int?pageSize, string sortBy, int page = 1)
{
var catalog = new SearchResultViewModel();
ViewData["BodyClass"] = "shop_grid_full_width_page";
if (pageSize == null)
{
pageSize = _configuration.GetValue <int>("PageSize");
}
catalog.PageSize = pageSize;
catalog.SortType = sortBy;
catalog.Data = _productService.GetAllPaging(null, keyword, page, pageSize.Value, string.Empty, null);
catalog.Keyword = keyword;
return(View(catalog));
}
public ViewResult SearchPage(SearchRequestViewModel searchRequestViewModel)
{
if (!ModelState.IsValid)
{
return(View(new SearchResultViewModel {
PageTitle = "Please Try Again"
}));
}
var searchTerm = searchRequestViewModel.SearchTerm;
var movies = _movieCatalogue.SearchMovies(searchTerm).ToList().Take(searchRequestViewModel.NumRows);
var viewModel = new SearchResultViewModel {
PageTitle = "Search Results", Movies = movies
};
return(View(viewModel));
}
public void SetUp()
{
photo1 = new SearchResultViewModel(
Substitute.For <IBitmap>(), "photo1");
photo2 = new SearchResultViewModel(
Substitute.For <IBitmap>(), "photo2");
var service = Substitute.For <IImageService>();
service.GetImages(Arg.Any <string>())
.Returns(new[] { photo1, photo2, }.ToObservable());
subject = new FlickrSearchViewModel(service)
{
SearchText = "cats"
};
}
public JsonResult Index(string keyword)
{
HtmlToText convert = new HtmlToText();
int ReportId = 0;
string s = keyword;
var searchResultList = new List <SearchResultViewModel>();
int result;
if (int.TryParse(s, out result))
{
ReportId = Convert.ToInt32(keyword);
}
else
{
}
IQueryable <Report> Reports = _applicationDbContext.Reports.Include(c => c.Category).Include(t => t.Topic).Include(ci => ci.City).Include(st => st.State);
if (!String.IsNullOrEmpty(keyword))
{
Reports = Reports
.Where(d => d.CompanyorIndividual.ToLower().Contains(keyword) || d.ReportId == ReportId ||
d.ReportText.ToLower().Contains(keyword) || d.Website.ToLower().Contains(keyword) ||
d.Address.ToLower().Contains(keyword) || d.Category.Name.ToLower().Contains(keyword)).OrderByDescending(d => d.DateCreated);
}
foreach (var report in Reports)
{
SearchResultViewModel model = new SearchResultViewModel();
string title = report.CompanyorIndividual + ":" + convert.Convert(report.ReportText.Substring(0, 90));
string titleC = Regex.Replace(title, "[^A-Za-z0-9]", "-");
model.iD = Guid.NewGuid().ToString();
model.page = report.ReportId;
model.title = titleC;
model.company = report.CompanyorIndividual;
model.Topic = report.Topic.Name;
model.Category = report.Category.Name;
searchResultList.Add(model);
}
return(Json(searchResultList, JsonRequestBehavior.AllowGet));
}
public ActionResult AdminIndex(int?page)
{
var pageNumber = page ?? 1;
var objectsPerPage = 20;
var searchResult = _recommendationRepository.Get(new SearchParamsBase
{
StartIndex = (pageNumber - 1) * objectsPerPage,
ObjectsCount = objectsPerPage,
});
var viewModel = SearchResultViewModel <Recommendation> .CreateFromSearchResult(searchResult, i => i, 10);
return(View(viewModel));
//var model = _recommendationRepository.GetAll();
//return View(model);
}
private SearchResultViewModel createViewModel(SearchResponse response)
{
var model = new SearchResultViewModel();
model.QueryWord = response.QueryWord;
foreach (var item in response.Results)
{
var itemViewModel = new SearchResultItemViewModel();
itemViewModel.Id = item.Id;
itemViewModel.Text = item.Title;
itemViewModel.SearchEngine = item.SearchEngine.ToString();
model.Items.Add(itemViewModel);
}
return(model);
}
public ActionResult Search(string keyWord, string returnUrl)
{
_logger.Info("Search for keyword {0} from page {1}", keyWord, returnUrl);
if (!string.IsNullOrEmpty(keyWord))
{
SearchResult response = _searchService.BasicSearch(keyWord);
SearchResultViewModel result = MapperHelper.GetValue <SearchResult, SearchResultViewModel>(response);
_logger.Info("Search for keyword {0} is succeeded with {1} results", keyWord,
(result.Albums.Count + result.Photos.Count + result.Users.Count).ToString());
TempData["SearchResult"] = result;
return(RedirectToAction("SearchResult"));
}
return(Redirect(returnUrl));
}
public ActionResult Search(string query, string sortBy = "relevant", int PageSize = 10, int StartIndex = 0)
{
var events = this.unitOfWork.EventRepository.Get(e => e.Status != (int)Statuses.Event.Disapprove && e.Status != (int)Statuses.Event.Delete);
SearchResultViewModel foundEvent = null;
if (!String.IsNullOrEmpty(query))
{
foundEvent = unitOfWork.EventRepository.Search(query, events, sortBy);
}
else
{
Session["Message"] = "Bạn muốn tìm kiếm gì ?";
Session["MessageType"] = "Error";
}
return(View(foundEvent));
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
if (e.Parameter is string terms)
{
var cache = ViewModelCacheManager.Instance.Peek <SearchResultViewModel>();
if (cache != null && cache.Terms == terms)
{
ViewModel = cache;
}
else
{
ViewModel = new SearchResultViewModel(terms);
ViewModelCacheManager.Instance.Push(ViewModel);
}
Bindings.Update();
}
}
public ActionResult SearchGroup(CreateSearchBindingModel model)
{
var groups = this.Data.Group.All()
.Where(group => group.Name.Contains(model.SerachWords))
.OrderByDescending(group => group.CreatedTime)
.Select(ViewModelsHelper.AsGroupViewModel)
.Where(models => models.IsDisplay)
.ToList().Take(5);
var searchResult = new SearchResultViewModel
{
Groups = groups,
};
ViewData["SearchWords"] = model.SerachWords;
return(this.View(searchResult));
}
/// <summary>
/// <inheritdoc />
/// </summary>
/// <param name="condition"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task <SearchResultViewModel <IList <Skill> > > SearchSkillsAsync(SearchSkillViewModel condition,
CancellationToken cancellationToken = default(CancellationToken))
{
var skills = GetSkills(condition);
var loadSkillResult = new SearchResultViewModel <IList <Skill> >();
loadSkillResult.Total = await skills.CountAsync(cancellationToken);
//do sorting
skills = _dbService.Sort(skills, SortDirection.Ascending, UserDescriptionSortProperty.Id);
// Do pagination.
skills = _dbService.Paginate(skills, condition.Pagination);
loadSkillResult.Records = await skills.ToListAsync(cancellationToken);
return(loadSkillResult);
}
public ActionResult SearchResult(string searchtext)
{
SearchResultViewModel model = new SearchResultViewModel();
model.SearchString = searchtext;
model.Posts = db.Posts.ToList().FindAll(post =>
(post.Title != null) ? post.Title.ToUpper().Contains(searchtext.ToUpper()) : false ||
(post.Body != null) ? post.Body.ToUpper().Contains(searchtext.ToUpper()) : false
);
model.Blogs = db.Blogs.ToList().FindAll(blog =>
(blog.Title != null) ? ((blog.Title).ToUpper()).Contains(searchtext.ToUpper()) : false ||
(blog.Description != null) ? blog.Description.ToUpper().Contains(searchtext.ToUpper()) : false
);
return(View(model));
}
public SearchResultViewModel Search(string searchValue, string category)
{
SearchResultViewModel searchResult = new SearchResultViewModel();
switch (category)
{
case "Maskiner":
searchResult = FindMachines(searchResult, searchValue);
break;
case "Kontakter":
searchResult = FindContacts(searchResult, searchValue);
break;
case "Manualer":
searchResult = FindManuals(searchResult, searchValue);
break;
case "Prospekter":
searchResult = FindProspects(searchResult, searchValue);
break;
case "Tilbud":
searchResult = FindQuotations(searchResult, searchValue);
break;
case "Reservedele":
searchResult = FindSpareParts(searchResult, searchValue);
break;
case "Kunder":
searchResult = FindCustomer(searchResult, searchValue);
break;
case "Besøg":
searchResult = FindVisit(searchResult, searchValue);
break;
default:
return(searchResult);
}
return(searchResult);
}
internal SearchResultViewModel Search(SearchViewModel searchViewModel, int skip, int take)
{
var result = new SearchResultViewModel
{
Attributes = searchViewModel
};
using (var context = new ApplicationContext())
{
IQueryable <Request> query = context.Requests
.Where(x => x.Status == RequestStatus.ACTIVE);
if (searchViewModel.CategoryId != 0)
{
query = query.Where(x => x.Category.Id == searchViewModel.CategoryId);
}
if (!string.IsNullOrEmpty(searchViewModel.Keywords))
{
query = query.Where(x => x.Keywords.Contains(searchViewModel.Keywords));
}
if (!string.IsNullOrEmpty(searchViewModel.Query))
{
query = query.Where(x => x.Title.Contains(searchViewModel.Query) ||
x.Subtitle.Contains(searchViewModel.Query));
}
result.Quantity = query.Count();
result.Requests = query.Select(request => new RequestViewModel {
Id = request.Id,
CategoryId = request.Category.Id,
Title = request.Title,
Subtitle = request.Subtitle,
Progress = request.Progress,
Photo = Utils.SessionFacade.RootUrl + "/Donation/Photo/" + request.Id
})
.OrderByDescending(x => x.Id)
.Skip(skip).Take(take).ToList();
}
return(result);
}
public async Task <SearchResultViewModel> GetSearchResultAsync(string query)
{
var url = @"https://www.google.com/search?q=" + WebUtility.UrlEncode(query);
var responseString = await GetHtmlPageAsync(url);
var htmlDoc = new HtmlDocument();
htmlDoc.LoadHtml(responseString);
var xpath = @"//div/div/div[@class='kCrYT']/a";
var nodes = htmlDoc.DocumentNode.SelectNodes(xpath);
if (nodes == null)
{
throw new Exception("No results were found");
}
var searchResultsItems = new List <SearchResultItem>();
foreach (var node in nodes)
{
searchResultsItems.Add(new SearchResultItem
{
Title = WebUtility.HtmlDecode(node.ChildNodes[0].InnerText),
Link = WebUtility.UrlDecode(GetResultUrl(node.Attributes["href"].Value))
});
if (searchResultsItems.Count == 10)
{
break;
}
}
var searchResults = new SearchResultViewModel()
{
ResultsList = searchResultsItems,
Date = DateTime.Now,
SearchEngineName = SearchEngineName.Google,
Query = query
};
return(searchResults);
}
/// <summary>
/// <inheritdoc />
/// </summary>
/// <param name="condition"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task <SearchResultViewModel <IList <UserDescription> > > SearchUserDescriptionsAsync(SearchUserDescriptionViewModel condition,
CancellationToken cancellationToken = default(CancellationToken))
{
var userDescriptions = GetUserDescriptions(condition);
var loadUserDescriptionResult = new SearchResultViewModel <IList <UserDescription> >();
loadUserDescriptionResult.Total = await userDescriptions.CountAsync(cancellationToken);
// Do sorting.
userDescriptions =
_dbService.Sort(userDescriptions, SortDirection.Ascending, UserDescriptionSortProperty.Id);
// Do pagination.
userDescriptions = _dbService.Paginate(userDescriptions, condition.Pagination);
loadUserDescriptionResult.Records = await userDescriptions.ToListAsync(cancellationToken);
return(loadUserDescriptionResult);
}
public async Task <SearchResultViewModel <IList <Skill> > > SearchSkillsAsync(SearchSkillViewModel condition,
CancellationToken cancellationToken = default(CancellationToken))
{
var skills = _dbContext.Skills.AsQueryable();
if (condition.Ids != null && condition.Ids.Count > 0)
{
var ids = condition.Ids.Where(c => c > 0).ToList();
if (ids.Count > 0)
{
skills = skills.Where(c => ids.Contains(c.Id));
}
}
if (condition.Names != null && condition.Names.Count > 0)
{
var names = condition.Names.Where(c => !string.IsNullOrEmpty(c)).ToList();
if (names.Count > 0)
{
skills = skills.Where(c => names.Contains(c.Name));
}
}
if (condition.StartedTime != null)
{
skills = skills.Where(c => c.CreatedTime >= condition.StartedTime.From &&
c.CreatedTime <= condition.StartedTime.To);
}
var result = new SearchResultViewModel <IList <Skill> >();
result.Total = await skills.CountAsync(cancellationToken);
//do sorting
skills = _dbService.Sort(skills, SortDirection.Ascending, UserDescriptionSortProperty.Id);
// Do pagination.
skills = _dbService.Paginate(skills, condition.Pagination);
result.Records = await skills.ToListAsync(cancellationToken);
return(result);
}
public SearchResultViewModel Search(string query, string user_id)
{
try
{
List <Person> searchlist = pRODEntities.People.Where(a => a.fullName.Contains(query) && a.user_id != user_id).ToList();
Person person = pRODEntities.People.Include("Tweets").Include("Person1").Include("People").Where(a => a.user_id == user_id).First();
SearchResultViewModel searchResultViewModel = new SearchResultViewModel
{
AvailableUsers = searchlist,
Following = person.People.ToList()
};
return(searchResultViewModel);
}
catch (Exception ex)
{
Log.Fatal("Exception at Person Repositiry - Search", ex);
throw;
}
}
public async Task <ActionResult> Search(SearchViewModel searchViewModel)
{
var searchAlgorithm = SearchFactory.GetSearchAlgorithm(searchViewModel.Url);
var searchResultViewModel = new SearchResultViewModel();
try
{
var result = await searchAlgorithm.GetSearchResultPageNumbers(searchViewModel.Keywords);
searchResultViewModel.SearchResults = result;
}
catch (ReadableException ex)
{
searchResultViewModel.SearchResults = $"Ooops: {ex.Message}";
}
return(View(searchResultViewModel));
}
private void SortTitlesByRelevancy(SearchResultViewModel result, string searchTerm)
{
if (result.DisplayTitle == null)
{
return;
}
var lowerTerm = searchTerm.ToLower();
for (var i = 0; i < result.DisplayTitle.Count; i++)
{
var title = result.DisplayTitle[i];
if (!PathwaySearchResult.StripHighlightMarkup(title).ToLower().Contains(lowerTerm))
{
continue;
}
result.DisplayTitle.RemoveAt(i);
result.DisplayTitle.Insert(0, title);
}
}
public async Task <SearchResultViewModel> GetSearchResultAsync(string query)
{
var url = @"https://yandex.com/search/?text=" + WebUtility.UrlEncode(query);
var responseString = await GetHtmlPageAsync(url);
var htmlDoc = new HtmlDocument();
htmlDoc.LoadHtml(responseString);
var xpath = @"//a[@class='link link_theme_normal organic__url link_cropped_no i-bem']";
var nodes = htmlDoc.DocumentNode.SelectNodes(xpath);
if (nodes == null)
{
throw new Exception("No results were found");
}
var searchResultsItems = new List <SearchResultItem>();
foreach (var node in nodes)
{
searchResultsItems.Add(new SearchResultItem
{
Title = node.InnerText,
Link = node.Attributes["href"].Value
});
if (searchResultsItems.Count == 10)
{
break;
}
}
var searchResults = new SearchResultViewModel
{
ResultsList = searchResultsItems,
Date = DateTime.Now,
SearchEngineName = SearchEngineName.Yandex,
Query = query
};
return(searchResults);
}
public override SearchResultViewModel Execute(SchemaRepository repo)
{
SearchResultViewModel result = SearchResultViewModel.Empty;
List <Task <SearchResultViewModel> > tasks = new List <Task <SearchResultViewModel> >(_searches.Count);
foreach (var search in _searches)
{
tasks.Add(Task.Run(() => search.Execute(repo)));
}
Task.WaitAll(tasks.ToArray());
foreach (var task in tasks)
{
result = result.Merge(task.Result);
}
return(result);
}
/// <summary>
/// <inheritdoc />
/// </summary>
/// <param name="condition"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task <SearchResultViewModel <IList <User> > > GetUsersAsync(SearchUserViewModel condition, CancellationToken cancellationToken = default(CancellationToken))
{
var users = FindUsers(condition);
// Initialize search result.
var searchResult = new SearchResultViewModel <IList <User> >();
// Count total users.
searchResult.Total = await users.CountAsync(cancellationToken);
// Get pagination information.
var pagination = condition.Pagination;
users = _dbService.Paginate(users, pagination);
searchResult.Records = await users.ToListAsync(cancellationToken);
return(searchResult);
}
/// <summary>
/// <inheritdoc />
/// </summary>
/// <param name="condition"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task <SearchResultViewModel <IList <SkillCategory> > > SearchSkillCategoriesAsync(SearchSkillCategoryViewModel condition,
CancellationToken cancellationToken = default(CancellationToken))
{
var skillCategories = GetSkillCategories(condition);
// Get offline skill categories.
var loadSkillCategoriesResult = new SearchResultViewModel <IList <SkillCategory> >();
loadSkillCategoriesResult.Total = await skillCategories.CountAsync(cancellationToken);
// Do sorting.
skillCategories = _dbService.Sort(skillCategories, SortDirection.Ascending,
SkillCategorySortProperty.Id);
// Do paging.
skillCategories = _dbService.Paginate(skillCategories, condition.Pagination);
loadSkillCategoriesResult.Records = await skillCategories.ToListAsync(cancellationToken);
return(loadSkillCategoriesResult);
}
public async Task <IActionResult> Search(SearchResultViewModel searchResultViewModel, CancellationToken ct)
{
if (!ModelState.IsValid)
{
return(View("Index", searchResultViewModel));
}
var requestParameter = new SearchRequestParameter(searchResultViewModel.SearchCriteriaKeywords, searchResultViewModel.SearchCriteriaUrl);
var searchResponseResult = await _searchEngineService.SearchAsync(requestParameter, ct);
if (searchResponseResult.IsFailure)
{
return(RedirectToAction("Error"));
}
searchResultViewModel.ResultRanks = searchResponseResult.Value.ResultPositions;
return(View("Index", searchResultViewModel));
}
/// <summary>
/// <inheritdoc />
/// </summary>
/// <param name="condition"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <SearchResultViewModel <IList <Responsibility> > > SearchResponsibilitiesAsync(SearchResponsibilityViewModel condition,
CancellationToken cancellationToken = default(CancellationToken))
{
var responsibilities = GetResponsibilities(condition);
var result = new SearchResultViewModel <IList <Responsibility> >();
result.Total = await responsibilities.CountAsync(cancellationToken);
// Sort
responsibilities =
_dbService.Sort(responsibilities, SortDirection.Ascending, ResponsibilitySortProperty.Id);
// Paging
responsibilities = _dbService.Paginate(responsibilities, condition.Pagination);
result.Records = await responsibilities.ToListAsync(cancellationToken);
return(result);
}
public IActionResult Search(string keyword, int?pageSize, string sortBy, int page = 1)
{
ViewData["BodyClass"] = "shop_grid_full_width_page";
if (pageSize == null)
{
pageSize = _configuration.GetValue <int>("PageSize");
}
var searchVm = new SearchResultViewModel()
{
Data = _serviceRegistration.ProductService.GetAllPaging(null, keyword, page, pageSize.Value),
Keyword = keyword,
PageSize = pageSize,
SortType = sortBy
};
return(View(searchVm));
}
//Get LookupPoint
public IActionResult LookupPoint(string ident)
{
//Nếu SDB = null => quay về trang index
if (ident == null)
{
return(RedirectToAction("Index"));
}
//Tra về kq thí sinh
var result = (from s in _db.Results
from u in _db.Students
where s.CMND_Student == u.CMND && s.IdentNumber.Equals(ident)
select new
{
u.Name,
u.DateOfBirth,
s.MathScores,
s.EnglishScores,
s.LiteratureScores,
s.ChemiscalScores,
s.PhysicalScores,
s.BiologicalScores
}).FirstOrDefault();
if (result != null)
{
var finalResult = new SearchResultViewModel
{
Name = result.Name,
MathScore = result.MathScores,
BiologicalScores = result.BiologicalScores,
ChemiscalScores = result.ChemiscalScores,
EnglishScores = result.EnglishScores,
DateOfBirth = result.DateOfBirth,
LiteratureScores = result.LiteratureScores,
PhysicalScores = result.PhysicalScores
};
return(View(finalResult));
}
return(View(result));
}
public void HandleSearchResult(IMetadata result)
{
try
{
if (result == null)
return;
if (result is IArtist)
{
var artistKey = result.Location.ToString();
if (!artistResults.ContainsKey(artistKey))
{
var artistViewModel = new ArtistViewModel(mediaItemController, result as IArtist); //result.Location, result.Name, result.Summary, result.FromDate, result.ToDate, result.Thumbnail, result.ThumbnailData);
var resultViewModel = new SearchResultViewModel(artistViewModel);
artistResults.Add(artistKey, resultViewModel);
AddResult(resultViewModel);
}
}
else if (result is IAlbum)
{
var albumViewModel = new AlbumViewModel(mediaItemController, result as IAlbum); //result.Location, result.Name, result.Summary, result.Creator, result.CreatorName, result.FromDate, result.Thumbnail, result.ThumbnailData);
var artistKey = result.Creator.ToString();
var albumKey = result.Location.ToString();
if (!artistResults.ContainsKey(artistKey))
{
if (!albumResults.ContainsKey(albumKey))
{
var resultViewModel = new SearchResultViewModel(albumViewModel);
AddResult(resultViewModel);
albumResults.Add(albumKey, resultViewModel);
}
}
else
{
if (!albumResults.ContainsKey(albumKey))
{
var existing = artistResults[artistKey].Albums.Where(x => x.Id.ToString() == albumViewModel.Id.ToString()).FirstOrDefault();
if (existing == null)
{
AddAlbum(artistResults[artistKey], albumViewModel);
}
}
}
}
else if (result is ITrack)
{
var trackViewModel = new TrackViewModel(mediaItemController, result as ITrack); //result.Location, result.Name, result.Summary, result.Number, result.Duration, result.FromDate, result.Creator, result.CreatorName, result.Catalog, result.CatalogName, result.Target, result.TargetType, result.Thumbnail, result.ThumbnailData);
var albumKey = result.Catalog.ToString();
var trackKey = result.Location.ToString();
if (!albumResults.ContainsKey(albumKey))
{
if (!trackResults.ContainsKey(trackKey))
{
var resultViewModel = new SearchResultViewModel(trackViewModel);
trackResults.Add(trackKey, resultViewModel);
AddResult(resultViewModel);
}
}
else
{
if (!trackResults.ContainsKey(trackKey))
{
//var existing = albumResults[albumKey].Tracks.Where(x => x.Album.ToString() == trackViewModel.Album.ToString()).FirstOrDefault();
//if (existing == null)
//{
AddTrack(albumResults[albumKey], trackViewModel);
//}
}
}
}
else if (result is IClip)
{
var clipViewModel = new ClipViewModel(mediaItemController, result as IClip); //result.Location, result.Name, result.Summary, result.Number, result.Duration, result.Height, result.Width, result.FromDate, result.Creator, result.CreatorName, result.Catalog, result.CatalogName, result.Target, result.TargetType, result.Thumbnail, result.ThumbnailData);
var albumKey = result.Catalog.ToString();
var clipKey = result.Location.ToString();
if (!albumResults.ContainsKey(albumKey))
{
if (!clipResults.ContainsKey(clipKey))
{
var resultViewModel = new SearchResultViewModel(clipViewModel);
clipResults.Add(clipKey, resultViewModel);
AddResult(resultViewModel);
}
}
else
{
if (!clipResults.ContainsKey(clipKey))
{
//var existing = albumResults[albumKey].Tracks.Where(x => x.Album.ToString() == trackViewModel.Album.ToString()).FirstOrDefault();
//if (existing == null)
//{
AddClip(albumResults[albumKey], clipViewModel);
//}
}
}
}
}
catch (Exception ex)
{
logger.Error(" HandleSearchResults", ex);
}
}
public void SetUp()
{
photo1 = new SearchResultViewModel(
Substitute.For<IBitmap>(), "photo1");
photo2 = new SearchResultViewModel(
Substitute.For<IBitmap>(), "photo2");
var service = Substitute.For<IImageService>();
service.GetImages(Arg.Any<string>())
.Returns(
Observable.Create<SearchResultViewModel>(async obs =>
{
obs.OnNext(photo1);
obs.OnNext(photo2);
obs.OnCompleted();
}));
subject = new FlickrSearchViewModel(service)
{
SearchText = "cats"
};
}
private void ShowSearchResult(SearchResultModel model)
{
SearchResult = new SearchResultViewModel(this, model);
}
public void SetUp()
{
photo1 = new SearchResultViewModel(
Substitute.For<IBitmap>(), "photo1");
photo2 = new SearchResultViewModel(
Substitute.For<IBitmap>(), "photo2");
var service = Substitute.For<IImageService>();
service.GetImages(Arg.Any<string>())
.Returns(new[] { photo1, photo2, }.ToObservable());
subject = new FlickrSearchViewModel(service)
{
SearchText = "cats"
};
}
public ActionResult Search(string keyword)
{
SearchResultViewModel viewModel = new SearchResultViewModel();
viewModel.brandList = _brandRepository.GetList(0, 0, keyword, false);
viewModel.productList = _productRepository.GetList(0, keyword, false);
return PartialView(viewModel);
}
