public MarriageLicenseSearch()
{
InitializeComponent();
var model = new SearchResultsViewModel("Marriage");
BindingContext = model;
}
public async Task <ActionResult> SearchResults(SearchResultsViewModel viewModel)
{
SetBreadcrumb(viewModel.EntityType);
if (!ModelState.IsValid)
{
viewModel.Results = await organisationSearcher.Search(viewModel.SearchTerm, maximumSearchResults, false);
return(View(viewModel));
}
if (viewModel.EntityType == EntityType.Pcs)
{
var selectedOrg = viewModel.Results.FirstOrDefault(p => p.OrganisationId == viewModel.SelectedOrganisationId);
if (selectedOrg.PcsCount == 0)
{
return(RedirectToAction("AddScheme", "Scheme", new { organisationId = viewModel.SelectedOrganisationId }));
}
return(RedirectToAction("OrgAlreadyHasScheme", "AddOrganisation", new { searchTerm = viewModel.SearchTerm }));
}
return(RedirectToAction("Add", "AddAatf", new { organisationId = viewModel.SelectedOrganisationId, facilityType = viewModel.EntityType }));
}
public InspectResultsViewModel(MessageBus messageBus, GeospatialBox extent)
{
// create an isolated message bus
InnerMessageBus = new MessageBus();
InnerMessageBus.Subscribe <BuildSearchMessage>(async m =>
{
var query = new SearchQuery();
await messageBus.Publish(new BuildSearchMessage(query)); // get current global query
query.Viewport = extent;
var start = m.Query.Start;
m.Query.Apply(query);
m.Query.Start = start;
});
InnerMessageBus.Subscribe <EndSearchMessage>(m =>
{
_originalResults = _originalResults ?? m.Results;
NotifyPropertyChanged(nameof(Total));
});
// relay certain messages to outer bus so they can be resolved
InnerMessageBus.Subscribe <GetServerSettingsMessage>(m => messageBus.Publish(m));
FacetsViewModel = new SearchFacetsViewModel(InnerMessageBus);
ResultsViewModel = new SearchResultsViewModel(InnerMessageBus);
DocumentViewModel = new DocumentViewModel(InnerMessageBus);
}
/// <summary>
/// Builds facet counts.
/// </summary>
private static IEnumerable <FacetCount> BuildFacetCounts(
SearchResultsViewModel model,
string facetNotSelectedValue = "*Facet NOT Selected*"
)
{
if (model.SearchResults != null &&
model.SearchResults.FacetFields != null &&
model.SearchResults.FacetFields.Keys != null)
{
foreach (string facetKey in model.SearchResults.FacetFields.Keys)
{
ICollection <KeyValuePair <string, int> > facets = model.SearchResults.FacetFields[facetKey];
foreach (KeyValuePair <string, int> facetCount in facets)
{
// Try to replace the itemID with the Item Name.
Item item = null;
Guid itemId = Guid.Empty;
if (Guid.TryParse(facetCount.Key, out itemId) && itemId != Guid.Empty)
{
item = Context.Database.GetItem(new ID(itemId));
}
yield return(new FacetCount
{
Key = facetCount.Key,
Name = item != null ? item.Name : facetNotSelectedValue,
Count = facetCount.Value
});
}
}
}
}
public async Task PostSearchResults_WithSelectedPRN_RedirectsToDetailsAction()
{
// Arrange
BreadcrumbService breadcrumb = A.Dummy <BreadcrumbService>();
ISearcher <ProducerSearchResult> producerSearcher = A.Dummy <ISearcher <ProducerSearchResult> >();
Func <IWeeeClient> weeeClient = A.Dummy <Func <IWeeeClient> >();
ProducersController controller = new ProducersController(breadcrumb, producerSearcher, weeeClient, cache, configurationService);
SearchResultsViewModel viewModel = new SearchResultsViewModel()
{
SelectedRegistrationNumber = "WEE/AA1111AA"
};
// Act
ActionResult result = await controller.SearchResults(viewModel);
// Assert
RedirectToRouteResult redirectResult = result as RedirectToRouteResult;
Assert.NotNull(redirectResult);
Assert.Equal("Details", redirectResult.RouteValues["action"]);
Assert.Equal("WEE/AA1111AA", redirectResult.RouteValues["RegistrationNumber"]);
}
public IActionResult Result(string searchTerm)
{
if (string.IsNullOrWhiteSpace(searchTerm))
{
throw new BadRequestException(ErrorMessages.InvalidSearchKeyword);
}
var model = new SearchResultsViewModel
{
Date = DateTime.Today.ToString(GlobalConstants.RequiredWebDateTimeFormat),
SearchTerm = searchTerm
};
bool isIsin = this.service.IsIsin(model.CleanedSearch);
if (isIsin)
{
this.recentService.Save(this.User, this.Request.Path + this.Request.QueryString);
var classId = this.service.ByIsin(model.CleanedSearch);
return(this.RedirectToRoute(
EndpointsConstants.RouteDetails + EndpointsConstants.ShareClassArea,
new { area = EndpointsConstants.ShareClassArea, id = classId, date = model.Date }));
}
model.Results = this.service.ByName(model.CleanedSearch);
if (model.Results.ToList().Count > 0)
{
this.recentService.Save(this.User, this.Request.Path + $"?searchTerm={model.CleanedSearch}");
}
return(this.View(model));
}
public async Task <IActionResult> SearchResults(int pages, ProductQuery productQuery)
{
double priceLimitMax = 0;
double priceLimitMin = 0;
pages = (pages == 0) ? 1 : pages;
IQueryable <Product> allProducts = _productRepository.FetchAllProductsIncl();
if (allProducts.Count() > 0)
{
priceLimitMax = allProducts.Max(p => p.SalePrice);
priceLimitMin = allProducts.Min(p => p.SalePrice);
}
foreach (var filter in productQuery.Filters)
{
allProducts = allProducts.Where(filter);
}
var filteredProducts = allProducts.OrderByDynamic(productQuery.GetCriteria, productQuery.OrderDirection);
var vm = new SearchResultsViewModel()
{
DisplayMode = ProductListDisplayMode.CatalogView,
ProductList = await PaginatedList <Product> .CreateAsync(filteredProducts, pages, productsPerPage),
ProductQuery = productQuery,
priceLimitMax = priceLimitMax,
priceLimitMin = priceLimitMin
};
ViewData["CurrentSearch"] = productQuery.SearchString;
return(View(vm));
}
/// <summary>
/// Builds facet counts.
/// </summary>
private static string DetermineFacetName(SearchResultsViewModel model, Guid selectedFacetKey)
{
if (model.SearchResults != null &&
model.SearchResults.FacetFields != null &&
model.SearchResults.FacetFields.Keys != null)
{
foreach (string facetKey in model.SearchResults.FacetFields.Keys)
{
ICollection <KeyValuePair <string, int> > facets = model.SearchResults.FacetFields[facetKey];
foreach (KeyValuePair <string, int> facetCount in facets)
{
// Try to replace the itemID with the Item Name.
Item item = null;
Guid itemId = Guid.Empty;
if (Guid.TryParse(facetCount.Key, out itemId) &&
itemId != Guid.Empty &&
itemId == selectedFacetKey)
{
item = Context.Database.GetItem(new ID(itemId));
if (item != null)
{
return(item.Name);
}
}
}
}
}
return(string.Empty);
}
public ActionResult Details(int reference)
{
ItemsDetailViewModel detailItem = global.GetItemDetail(reference);
if (detailItem != null)
{
if (Session["errorMessage"] != null)
{
string postMessage = Session["errorMessage"].ToString();
Session.Remove("errorMessage");
ViewBag.ErrorMessage = postMessage;
}
if (Session["updateMessage"] != null)
{
string postMessage = Session["updateMessage"].ToString();
Session.Remove("updateMessage");
ViewBag.UpdateMessage = postMessage;
}
if (Session["currentSearch"] != null)
{
SearchResultsViewModel currentSearch = Session["currentSearch"] as SearchResultsViewModel;
ViewBag.ReturnUrl = "/Search/Result/" + currentSearch.Page;
}
return(View(detailItem));
}
return(RedirectToAction("Index", "Search"));
}
public async Task GetSearch_SearchTermThatExists_RedirectsToSearchResultsWithResultsInViewModel()
{
var organisationId = Guid.NewGuid();
const string searchTerm = "civica";
var entityType = fixture.Create <EntityType>();
IList <OrganisationSearchResult> results = new List <OrganisationSearchResult>()
{
new OrganisationSearchResult()
{
Name = searchTerm,
OrganisationId = organisationId
}
};
A.CallTo(() => organisationSearcher.Search(searchTerm, 5, false)).Returns(results);
var viewModel = new SearchResultsViewModel()
{
Results = results,
SearchTerm = searchTerm,
SelectedOrganisationId = organisationId
};
var result = await controller.SearchResults(searchTerm, entityType) as ViewResult;
var outputModel = result.Model as SearchResultsViewModel;
Assert.True(string.IsNullOrEmpty(result.ViewName) || result.ViewName == "SearchResults");
Assert.Equal(viewModel.SearchTerm, outputModel.SearchTerm);
Assert.Equal(viewModel.Results, outputModel.Results);
}
public async Task <IActionResult> SearchResultsAsync(SearchResultsViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var searchResult = await _resultLoader.FindUlnResultsAsync(User.GetUkPrn(), model.SearchUln.ToLong());
if (searchResult?.IsAllowed == true)
{
return(RedirectToRoute(searchResult.IsWithdrawn ? RouteConstants.ResultWithdrawnDetails : RouteConstants.ResultDetails, new { profileId = searchResult.RegistrationProfileId }));
}
else
{
await _cacheService.SetAsync(Constants.ResultsSearchCriteria, model.SearchUln);
var ulnResultsNotfoundModel = new UlnResultsNotFoundViewModel {
Uln = model.SearchUln.ToString()
};
await _cacheService.SetAsync(string.Concat(CacheKey, Constants.SearchResultsUlnNotFound), ulnResultsNotfoundModel, CacheExpiryTime.XSmall);
return(RedirectToRoute(RouteConstants.SearchResultsNotFound));
}
}
public LandRecordsSearch()
{
InitializeComponent();
var model = new SearchResultsViewModel("LandRecords");
BindingContext = model;
}
public ActionResult Search(StoreSearchViewModel ssvm, Int32 pageNumber = 1)
{
IEnumerable <Product> results;
if (ssvm.Location != 0)
{
var catFilter = new Func <Product, Boolean>(p => p.CategoryID == ssvm.Location);
results = _prodService.GetAll().Where(catFilter);
}
else
{
results = _prodService.GetAll();
}
if (!String.IsNullOrEmpty(ssvm.Term))
{
results = results.Where(p => p.Name.Contains(ssvm.Term));
}
var srvm = new SearchResultsViewModel();
srvm.ssvm = ssvm;
srvm.Products = Mapper.Map <List <ProductViewModel> >(results).ToPagedList(pageNumber, 9);
ssvm.SearchLocations = this.searchLocations();
return(View("SearchResults", srvm));
}
public async Task PostSearchForPcs_ValidViewModelSelectedOrganisationAlreadyHasPcs_RedirectsToOrgAlreadyHasPcs()
{
var organisationId = Guid.NewGuid();
var searchTerm = "civica";
IList <OrganisationSearchResult> results = new List <OrganisationSearchResult>()
{
new OrganisationSearchResult()
{
Name = searchTerm,
OrganisationId = organisationId,
PcsCount = 1
}
};
A.CallTo(() => organisationSearcher.Search(searchTerm, 5, false)).Returns(results);
var viewModel = new SearchResultsViewModel()
{
Results = results,
SearchTerm = searchTerm,
SelectedOrganisationId = organisationId,
EntityType = EntityType.Pcs
};
var result = await controller.SearchResults(viewModel) as RedirectToRouteResult;
result.RouteValues["action"].Should().Be("OrgAlreadyHasScheme");
result.RouteValues["controller"].Should().Be("AddOrganisation");
Assert.Equal(searchTerm, result.RouteValues["searchTerm"]);
}
public SearchResults()
{
InitializeComponent();
//Set datacontext
DataContext = new SearchResultsViewModel();
}
public async Task <IActionResult> SearchResults(SearchViewModel model)
{
var current = model.Current;
var results = new SearchResultsViewModel();
results.Current = current;
if (model.SearchInAlbums)
{
results.Albums = await this.albums.Find(model.SearchText);
}
if (model.SearchInUsers)
{
results.Users = await this.users.Find(model.SearchText);
}
if (model.SearchInPhotos)
{
results.Photos = await this.photos.Find(model.SearchText);
}
if (model.SearchInAds)
{
results.Ads = await this.ads.FindForListing(model.SearchText);
}
return(this.PartialView("_SearchResults", results));
}
public async Task <ActionResult> Search(string departure, string arrival)
{
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:64548/");
client.DefaultRequestHeaders.Accept.Clear();
string s = null;
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = await client.GetAsync($"api/Drivers/available/{departure}");
List <Driver> drivers = null;
if (response.IsSuccessStatusCode)
{
s = await response.Content.ReadAsStringAsync();
drivers = JsonConvert.DeserializeObject <List <Driver> >(s);
}
if (drivers == null || drivers.Count <= 0)
{
return(View("Index", new IndexViewModel("Aucun chauffeur n'a été trouvé pour le trajet spécifié")));
}
SearchResultsViewModel model = new SearchResultsViewModel(drivers, departure, arrival);
ViewBag.Script = "showDrivers.js";
ViewBag.GoogleScript = "https://maps.googleapis.com/maps/api/js?key=AIzaSyCDjKjiTE-YwsyVbG2KY4VVJF5w3F7XWt8&callback=initMap";
return(View(model));
}
public async Task PostSearch_InValidViewModelSelectedOrganisation_ReturnsView()
{
var organisationId = Guid.NewGuid();
const string searchTerm = "civica";
IList <OrganisationSearchResult> results = new List <OrganisationSearchResult>()
{
new OrganisationSearchResult()
{
Name = searchTerm,
OrganisationId = organisationId
}
};
A.CallTo(() => organisationSearcher.Search(searchTerm, 5, false)).Returns(results);
controller.ModelState.AddModelError("error", "error");
var viewModel = new SearchResultsViewModel()
{
Results = results,
SearchTerm = searchTerm,
SelectedOrganisationId = organisationId
};
var result = await controller.SearchResults(viewModel) as ViewResult;
var outputModel = result.Model as SearchResultsViewModel;
Assert.True(string.IsNullOrEmpty(result.ViewName) || result.ViewName == "SearchResults");
Assert.Equal(viewModel.SearchTerm, outputModel.SearchTerm);
Assert.Equal(viewModel.Results, outputModel.Results);
}
public ActionResult Result(SearchFormViewModel searchForm)
{
SearchResultsViewModel results = searchFormManager.Search(searchForm);
Session["currentSearch"] = results;
return(View(results));
}
public EnterpriseSearchResultPage()
{
InitializeComponent();
SearchResultList sampleList = new SearchResultList
{
Results = new System.Collections.Generic.List <SearchResult>()
{
new SearchResult()
{
Score = 0.9, Content = "Test search item 1", StoragePath = "https://www.google.com"
},
new SearchResult()
{
Score = 0.7, Content = "Test search item 2", StoragePath = "https://www.bing.com"
}
},
OriginalQuery = "search"
};
this.lblOriginalQuery.Text = sampleList.OriginalQuery;
var sampleViewModel = new SearchResultsViewModel(sampleList);
this.BindingContext = sampleViewModel;
}
public SearchController(
SearchResultsViewModel.Factory searchViewModelFactory,
IMusicProvider musicProvider)
{
_searchViewModelFactory = searchViewModelFactory;
_musicProvider = musicProvider;
}
public async Task PostSearchResults_WithSelectedOrganisationId_RedirectsToJoinOrganisationAction()
{
// Arrange
var organisationSearcher = A.Dummy <ISearcher <OrganisationSearchResult> >();
var weeeClient = A.Dummy <Func <IWeeeClient> >();
var controller = new OrganisationRegistrationController(
weeeClient,
organisationSearcher,
configurationService);
var viewModel = new SearchResultsViewModel()
{
SelectedOrganisationId = new Guid("05DF9AE8-DACE-4173-A227-16933EB5D5F8")
};
// Act
var result = await controller.SearchResults(viewModel);
// Assert
var redirectResult = result as RedirectToRouteResult;
Assert.NotNull(redirectResult);
Assert.Equal("JoinOrganisation", redirectResult.RouteValues["action"]);
Assert.Equal(new Guid("05DF9AE8-DACE-4173-A227-16933EB5D5F8"), redirectResult.RouteValues["OrganisationId"]);
}
public override void Given()
{
SearchResultsViewModel = new SearchResultsViewModel {
SearchUln = SearchUln
};
Controller.ModelState.AddModelError("SearchUln", SearchResultsContent.Uln_Not_Valid_Validation_Message);
}
public ActionResult Search(string query, int?page, string titlesonly)
{
var pageNumber = page ?? 1;
if (pageNumber <= 0)
{
pageNumber = 1;
}
var q = new SearchQuery
{
Query = query,
CurrentPage = pageNumber,
TitlesOnly = !string.IsNullOrWhiteSpace(titlesonly),
};
var vm = new SearchResultsViewModel {
Query = q, SearchResults = new List <SearchResultsViewModel.SearchResult>(), TotalResults = 0
};
try
{
vm = Core.Index.SearchWithSuggestions(q);
}
catch (ParseException ex)
{
ViewBag.ErrorMessage = "Error: " + ex.Message;
}
ViewBag.Query = q;
return(View(vm));
}
private async Task <SearchResultsViewModel> GetSearchResults(string route, string postcode, int distance)
{
var viewModel = new SearchResultsViewModel();
viewModel.Route = route;
viewModel.Distance = distance;
viewModel.Postcode = postcode;
var routeId = route.Replace("-", " ");
var routes = _repository.GetRoutes();
var searchTask = _vacanciesService.GetByRoute(routeId, postcode, Convert.ToInt32(distance));
await Task.WhenAll(routes, searchTask);
var searchResults = searchTask.Result;
if (searchResults != null)
{
viewModel.TotalResults = searchResults.Results.Count;
viewModel.Results = searchResults.Results.Where(w => w.DistanceInMiles <= distance).Take(100).ToList();
viewModel.Location = searchResults.searchLocation;
viewModel.StaticMapUrl = _mappingService.GetStaticMapsUrl(searchResults.Results.Select(p => p.Location), "680", "530");
viewModel.Country = searchResults.Country;
viewModel.Routes = routes.Result;
}
return(viewModel);
}
public async Task PostSearchForAatf_ValidViewModelSelectedOrganisation_RedirectsToAdd()
{
var organisationId = Guid.NewGuid();
var searchTerm = "civica";
IList <OrganisationSearchResult> results = new List <OrganisationSearchResult>()
{
new OrganisationSearchResult()
{
Name = searchTerm,
OrganisationId = organisationId
}
};
A.CallTo(() => organisationSearcher.Search(searchTerm, 5, false)).Returns(results);
var viewModel = new SearchResultsViewModel()
{
Results = results,
SearchTerm = searchTerm,
SelectedOrganisationId = organisationId,
EntityType = EntityType.Aatf
};
var result = await controller.SearchResults(viewModel) as RedirectToRouteResult;
result.RouteValues["action"].Should().Be("Add");
result.RouteValues["controller"].Should().Be("AddAatf");
Assert.Equal(organisationId, result.RouteValues["organisationId"]);
}
public PartialViewResult SubmitBikeSearch(BikeSearchViewModel viewModel)
{
var resultsViewModel = new SearchResultsViewModel();
var results = _searchService.SearchBikeCards(viewModel);
resultsViewModel.CountBikes = _searchService.GetCountAllBikes(viewModel.SearchTerm);
foreach (var result in results)
{
var bike = _bikeCardService.GetBikeCardContent(result.ItemId.ToString());
resultsViewModel.Results.Add(new SearchResultViewModel()
{
Id = result.ItemId.ToString(),
BikeName = result.BikeName,
TypeEngine = result.TypeEngine,
MaxSpeed = result.MaxSpeed,
ImgUrl = bike.Image.Src,
Fuel = result.Fuel,
Description = result.Description,
Price = result.Price
});
}
return(PartialView("~/Areas/ATV/Views/Search/_BikeSearchResult.cshtml", resultsViewModel));
}
public IActionResult GetNextSearchResults([FromQuery] SearchResultsViewModel model)
{
var allResults = _searchManager.Search(model.SearchValue.Trim().ToLower(), model.SearchType);
int toTake = 0;
if (allResults.Count > model.Take + model.Skip)
{
toTake = model.Take;
}
else
{
toTake = allResults.Count - model.Skip;
}
if (toTake > 0)
{
for (int i = 0; i < model.Skip; i++)
{
allResults.Dequeue();
}
}
for (int i = 0; i < toTake; i++)
{
model.Results.Enqueue(allResults.Peek(), allResults.PeekPriority());
allResults.Dequeue();
}
return(View(model));
}
public ActionResult Results(SearchRequestViewModel model)
{
SearchResultsViewModel results = null;
if (ModelState.IsValid)
{
results = GetCommand <SearchQueryCommand>().ExecuteCommand(model);
}
else
{
var errorMessage = SearchGlobalization.SearchResults_FailedToGetResults;
var modelError = ModelState.Values.SelectMany(v => v.Errors).Select(v => v.ErrorMessage).FirstOrDefault();
if (!string.IsNullOrWhiteSpace(modelError))
{
errorMessage = string.Concat(errorMessage, " ", modelError);
}
Messages.AddError(errorMessage);
}
if (results == null && Messages.Error != null && Messages.Error.Count > 0)
{
results = new SearchResultsViewModel {
ErrorMessage = Messages.Error[0]
};
}
return(PartialView("SearchResultsWidget", results));
}
public IActionResult SearchResult(SearchViewModel model)
{
if (this.ModelState.IsValid)
{
var result = new FolloweeFromApiDto[0];
try
{
result = twitterApiCallService.GetTwitterUsersByScreenName(model.SearchInput);
}
catch (Exception e)
{
return(this.View("NotFound"));
}
if (result.Length < 1)
{
TempData["Not-Found-Message"] = $"No results found matching {model.SearchInput}";
return(RedirectToAction("Search"));
}
var vm = new SearchResultsViewModel {
SearchResults = result
};
return(this.View(vm));
}
return(this.View());
}
// GET: Rentals
public virtual ActionResult SearchResult(SearchViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(MVC.Home.Views.Index, viewModel));
}
var returnDate = viewModel.ReturnDate;
var pickupDate = viewModel.PickupDate;
var cars = context.Cars.Include(car => car.CarGroup).AsEnumerable();
var rentals = context.Rentals.AsEnumerable();
foreach (var rental in rentals)
{
if (rental.PickupDate < returnDate && pickupDate < rental.ReturnDate)
{
cars = cars.Where(car => car.Id != rental.CarId);
}
}
var resultCarGroupsIds = new List <int>();
foreach (var car in cars)
{
resultCarGroupsIds.Add(car.CarGroupId);
}
resultCarGroupsIds = resultCarGroupsIds.Distinct().ToList();
var resultCarGroups = context.CarGroups.Include(c => c.CarGroupDetails).Where(x => resultCarGroupsIds.Contains(x.Id));
var searchResultsModel = new SearchResultsViewModel(resultCarGroups, pickupDate, returnDate);
return(View(MVC.Rentals.Views.SearchResult, searchResultsModel));
}
public async Task<ActionResult> SearchResults(string searchTerm)
{
SearchResultsViewModel viewModel = new SearchResultsViewModel();
viewModel.SearchTerm = searchTerm;
viewModel.Results = await organisationSearcher.Search(searchTerm, maximumSearchResults, false);
return View(viewModel);
}
public async Task<ActionResult> SearchResults(SearchResultsViewModel viewModel)
{
if (!ModelState.IsValid)
{
viewModel.Results = await organisationSearcher.Search(viewModel.SearchTerm, maximumSearchResults, false);
return View(viewModel);
}
return RedirectToAction("JoinOrganisation", new
{
OrganisationId = viewModel.SelectedOrganisationId.Value
});
}
public ActionResult PerformSearch(string searchText, string filter)
{
var resp = _userManager.GetUserSearchByNameAndFilter(new UserSearchRequest() { SearchText = searchText.Trim(), RoleFilter = (filter == "All") ? string.Empty : filter.Trim() });
var m = new SearchResultsViewModel();
foreach (var item in resp.Values)
{
m.Results.Add(new SearchResult()
{
DisplayName = String.Format("{0}, {1}", item.LastName, item.FirstName),
EmailAddress = item.EmailAddress,
UserId = item.UserId,
MembershipId = item.MembershipGuid,
AccountType = item.UserType.ToString()
});
}
var uiresult = new UIResponse<SearchResultsViewModel>();
uiresult.Subject = m;
uiresult.HtmlResult = RenderPartialViewToString("SearchResults", m);
uiresult.Status = resp.Status;
return Json(uiresult, JsonRequestBehavior.AllowGet);
}
//Prepares the exact address property object for view
//If the address exists in DB, configure its lat/lng
//If it doesnt, configure it for the view and give its needed data for the view.
private SearchResultsViewModel ConfigureExactAddressForView(SearchCompare geocodedAddress)
{
Geography locationData;
var exactproperty = SearchForExactAddressLocation(geocodedAddress);
if (exactproperty != null)
{
exactproperty.type = "exact";
if (exactproperty.latitude == 0m)
{
locationData = GetLatLng(exactproperty.formatted_address);
if (locationData != null)
{
exactproperty.latitude = locationData.latitude;
exactproperty.longitude = locationData.longitude;
}
}
return exactproperty;
}
else
{
SearchResultsViewModel V1 = new SearchResultsViewModel();
V1.propertyID = 0;
V1.formatted_address = geocodedAddress.formatted_address;
V1.latitude = geocodedAddress.latitude;
V1.longitude = geocodedAddress.longitude;
V1.type = "exact-new";
return V1;
}
}
//*************************
//SEARCH Functions
//*************************
//GET
public ActionResult Search(string locationinput, int? pagenum)
{
if (locationinput == null) { return RedirectToAction("Index", "Home");}
if (pagenum == null) { pagenum = 1; }
//Geocode input address
SearchCompare geocodedAddress = Geocode(locationinput);
if (geocodedAddress == null) { return null; }
SearchResultsViewModel exactproperty = new SearchResultsViewModel();
List<SearchResultsViewModel> relatedproperties = null;
if (pagenum == 1 && geocodedAddress.type == GoogleAddressType.StreetAddress) {
exactproperty = ConfigureExactAddressForView(geocodedAddress);
}
relatedproperties = SearchAllRelatedProperties(geocodedAddress, exactproperty.propertyID);
if (exactproperty.type != null) {
relatedproperties.Insert(0, exactproperty);
}
var results = OnePageOfResults(relatedproperties, pagenum);
ViewBag.address = geocodedAddress.formatted_address;
return View(results);
}
public async Task PostSearchResults_WithSelectedOrganisationId_RedirectsToJoinOrganisationAction()
{
// Arrange
ISearcher<OrganisationSearchResult> organisationSearcher = A.Dummy<ISearcher<OrganisationSearchResult>>();
Func<IWeeeClient> weeeClient = A.Dummy<Func<IWeeeClient>>();
OrganisationRegistrationController controller = new OrganisationRegistrationController(
weeeClient,
organisationSearcher);
SearchResultsViewModel viewModel = new SearchResultsViewModel()
{
SelectedOrganisationId = new Guid("05DF9AE8-DACE-4173-A227-16933EB5D5F8")
};
// Act
ActionResult result = await controller.SearchResults(viewModel);
// Assert
RedirectToRouteResult redirectResult = result as RedirectToRouteResult;
Assert.NotNull(redirectResult);
Assert.Equal("JoinOrganisation", redirectResult.RouteValues["action"]);
Assert.Equal(new Guid("05DF9AE8-DACE-4173-A227-16933EB5D5F8"), redirectResult.RouteValues["OrganisationId"]);
}
public async Task PostSearchResults_WithInvalidModel_DoesSearchForFiveResultsAndReturnsSearchReturnsView()
{
// Arrange
List<OrganisationSearchResult> fakeResults = new List<OrganisationSearchResult>()
{
new OrganisationSearchResult()
{
OrganisationId = new Guid("05DF9AE8-DACE-4173-A227-16933EB5D5F8"),
Name = "Test Company",
}
};
ISearcher<OrganisationSearchResult> organisationSearcher = A.Fake<ISearcher<OrganisationSearchResult>>();
A.CallTo(() => organisationSearcher.Search("testSearchTerm", 5, false))
.Returns(fakeResults);
Func<IWeeeClient> weeeClient = A.Dummy<Func<IWeeeClient>>();
OrganisationRegistrationController controller = new OrganisationRegistrationController(
weeeClient,
organisationSearcher);
SearchResultsViewModel viewModel = new SearchResultsViewModel();
viewModel.SearchTerm = "testSearchTerm";
controller.ModelState.AddModelError("SomeProperty", "Exception");
// Act
ActionResult result = await controller.SearchResults(viewModel);
// Assert
ViewResult viewResult = result as ViewResult;
Assert.NotNull(viewResult);
Assert.True(string.IsNullOrEmpty(viewResult.ViewName) || viewResult.ViewName.ToLowerInvariant() == "searchresults");
SearchResultsViewModel resultsViewModel = viewResult.Model as SearchResultsViewModel;
Assert.NotNull(resultsViewModel);
Assert.Contains(resultsViewModel.Results, r => r.OrganisationId == new Guid("05DF9AE8-DACE-4173-A227-16933EB5D5F8"));
}
public ActionResult Search(string Search)
{
using (ForumRespository db = new ForumRespository())
{
Forum_User CurrentUser = GetCurrentUser(db);
var Model = new SearchResultsViewModel() { SearchString = Search };
Model.AddNavigation("Search Results");
if (!db.CheckRolePermissions(CurrentUser, R => R.AllowSearch))
return AuthenticationHelper.AccessDeniedView(Model);
var Posts = db.GetMatchingPosts(Search);
var Threads = db.GetMatchingThreads(Search);
Model.ResultCount = Posts.Count() + Threads.Count();
// Temp
int I = 0;
ThreadInfoModelFromThread(db, CurrentUser, Threads.Take(THREADS_PER_PAGE), Model.ThreadInfoList);
foreach (var Post in Posts.Take(POSTS_PER_PAGE))
{
Model.PostInfoList.Add(new PostWithThread()
{
ThreadName = Post.Forum_Thread.Title,
Post = new PostViewModel()
{
Locked = true,
PostID = Post.PostID,
PostNumber = ++I,
PostText = PostParser.Parse(Post.PostText),
PostTime = Post.TimeStamp,
ThreadID = Post.ThreadID,
Poster = new UserViewModel()
{
Name = Post.Forum_User.Username,
UserID = Post.Forum_User.UserID
}
}
});
}
return View("SearchResults", Model);
}
}
private void View_Loaded(object sender, System.Windows.RoutedEventArgs e)
{
ViewModel = _container.Register(Component.For<SearchResultsViewModel>().LifeStyle.Transient).Resolve<SearchResultsViewModel>();
ViewModel.Initialize();
}
public ActionResult Search(string searchTerm, string searchType)
{
if (string.IsNullOrWhiteSpace(searchTerm))
{
return Redirect("~");
}
searchType = (searchType ?? "all").ToLower();
var viewModel = new SearchResultsViewModel();
viewModel.SearchTerm = searchTerm;
var searchTerms = searchTerm.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
if (searchType == "all" || searchType == "show")
{
var query = DatabaseSession.Query<Show>()
.Fetch(x => x.Photo).AsQueryable();
foreach (var term in searchTerms)
{
query = query.Where(x => x.Title.Contains(term));
}
var shows = query.ToList();
viewModel.Results.AddRange(shows.Select(x => new SearchResultsViewModel.SearchResult
{
Name = x.Title,
Year = x.Year.ToString(),
SortField = x.Title,
ImageUrl = x.Photo.GetTinyFileURL(),
LinkUrl = Url.Action<ShowController>(c => c.ShowDetails(x.ShowId)),
}));
}
if (searchType == "all" || searchType == "peep")
{
var query = DatabaseSession.Query<Person>()
.Fetch(x => x.Photo).AsQueryable();
foreach (var term in searchTerms)
{
query = query.Where(x => x.LastName.Contains(term) ||
x.FirstName.Contains(term) ||
x.Nickname.Contains(term));
}
var people = query.ToList();
viewModel.Results.AddRange(people.Select(x => new SearchResultsViewModel.SearchResult
{
Name = x.Fullname,
SortField = x.LastName,
ImageUrl = x.Photo.GetTinyFileURL(),
LinkUrl = Url.Action<PersonController>(c => c.PersonDetails(x.PersonId)),
}));
}
if (viewModel.Results.Count == 1)
{
return Redirect(viewModel.Results[0].LinkUrl);
}
ViewBag.SearchTerm = searchTerm;
return View(viewModel);
}
