public async Task <ViewResult> Index(FashionNode currentContent, FilterOptionViewModel viewModel)
{
var model = _viewModelFactory.Create(currentContent, viewModel);
if (HttpContext.Request.HttpMethod == "GET")
{
var trackingResult = await _recommendationService.TrackCategoryAsync(HttpContext, currentContent);
model.Recommendations = trackingResult.GetCategoryRecommendations(_referenceConverter);
}
return(View(model));
}
public ActionResult Index(SearchPage currentPage, FilterOptionViewModel filterOptions)
{
var viewModel = _viewModelFactory.Create(currentPage, filterOptions);
if (filterOptions.Page <= 1)
{
viewModel.Recommendations = _recommendationService
.SendSearchTracking(HttpContext, filterOptions.Q, viewModel.ProductViewModels.Select(x => x.Code))
.GetSearchResultRecommendations(_referenceConverter);
}
return(View(viewModel));
}
public IEnumerable <ProductViewModel> QuickSearch(FilterOptionViewModel filterOptions)
{
if (string.IsNullOrEmpty(filterOptions.Q))
{
return(Enumerable.Empty <ProductViewModel>());
}
var query = BuildSearchQuery(null, filterOptions);
var searchResults = query.GetContentResult();
return(CreateProductViewModels(searchResults));
}
public void Create_WhenQStartsWithStar_ShouldReportAsError()
{
// Arrange
var formModel = new FilterOptionViewModel()
{
Q = "*query"
};
// Act
var result = _subject.Create <IContent>(null, formModel);
// Assert
Assert.True(result.HasError);
}
public void Search_WhenQueryContainsWaveCharacter_ShouldRemoveWaveCharacterFromQuery()
{
const string searchQuery = "start~end";
const string expectedResult = "startend*";
var content = new NodeContent();
var filterOptions = new FilterOptionViewModel {
Q = searchQuery, FacetGroups = new List <FacetGroupOption>()
};
_subject.Search(content, filterOptions);
_searchFacadeMock.Verify(x => x.Search(It.Is <CatalogEntrySearchCriteria>(y => y.SearchPhrase.Equals(expectedResult))));
}
public void Create_WhenPassingFormModel_ShouldUseItAsFormModel()
{
// Arrange
var formModel = new FilterOptionViewModel()
{
Q = "query"
};
// Act
var result = _subject.Create <IContent>(null, formModel);
// Assert
Assert.Equal <FilterOptionViewModel>(formModel, result.FilterOption);
}
public void Create_WhenSearching_ShouldGetFacetsFromSearchResult()
{
// Arrange
var formModel = new FilterOptionViewModel()
{
Q = "query"
};
// Act
var result = _subject.Create <IContent>(null, formModel);
// Assert
Assert.Equal <ISearchFacetGroup[]>(_facetGroups, result.Facets);
}
private bool IsSelectedFacet(string facetGroup, string term, FilterOptionViewModel filterOptions)
{
var filterOption = filterOptions.FacetGroups.FirstOrDefault(x => x.GroupFieldName == facetGroup);
if (filterOption != null)
{
var facetValue = filterOption.Facets.FirstOrDefault();
if (facetValue.Key.Equals(term, StringComparison.CurrentCultureIgnoreCase))
{
return(true);
}
}
return(false);
}
public void Create_WhenSearching_ShouldGetProductViewModelsFromSearchResult()
{
// Arrange
var formModel = new FilterOptionViewModel()
{
Q = "query"
};
// Act
var result = _subject.Create <IContent>(null, formModel);
// Assert
Assert.Equal <IEnumerable <ProductTileViewModel> >(_productViewModels, result.ProductViewModels);
}
private ProductSearchResults GetSearchResults(string language, ProductSearchBlock productSearchBlock)
{
var filterOptions = new FilterOptionViewModel
{
Q = productSearchBlock.SearchTerm,
PageSize = productSearchBlock.ResultsPerPage,
Sort = string.Empty,
FacetGroups = new List <FacetGroupOption>(),
Page = 1
};
var filters = GetFilters(productSearchBlock);
return(_searchService.SearchWithFilters(null, filterOptions, filters));
}
public async Task <ActionResult> Index(SearchPage currentPage, FilterOptionViewModel filterOptions)
{
var viewModel = _viewModelFactory.Create(currentPage, filterOptions);
if (filterOptions.Page <= 1)
{
var trackingResult =
await _recommendationService.TrackSearch(HttpContext, filterOptions.Q,
viewModel.ProductViewModels.Select(x => x.Code));
viewModel.Recommendations = trackingResult.GetSearchResultRecommendations(_referenceConverter);
}
return(View(viewModel));
}
public void Create_WhenPassingContent_ShouldUseItAsCurrentContent()
{
// Arrange
var formModel = new FilterOptionViewModel()
{
Q = "query"
};
var content = new Mock <IContent>().Object;
// Act
var result = _subject.Create <IContent>(content, formModel);
// Assert
Assert.Equal <IContent>(content, result.CurrentContent);
}
public ActionResult Index(SearchPage currentPage, FilterOptionViewModel filterOptions)
{
var viewModel = _viewModelFactory.Create(currentPage, filterOptions);
if (filterOptions.Page <= 1 && HttpContext.Request.HttpMethod == "GET")
{
HttpContext.Items[SearchTrackingData.TotalSearchResultsKey] = filterOptions.TotalCount;
viewModel.Recommendations = _recommendationService
.SendSearchTracking(HttpContext, filterOptions.Q, viewModel.ProductViewModels.Select(x => x.Code))
.GetSearchResultRecommendations(_referenceConverter);
}
return(View(viewModel));
}
public virtual SearchViewModel <T> Create <T>(T currentContent, FilterOptionViewModel viewModel) where T : IContent
{
if (viewModel.Q != null && (viewModel.Q.StartsWith("*") || viewModel.Q.StartsWith("?")))
{
return(new SearchViewModel <T>
{
CurrentContent = currentContent,
FilterOption = viewModel,
HasError = true,
ErrorMessage = _localizationService.GetString("/Search/BadFirstCharacter")
});
}
if (!String.IsNullOrEmpty(viewModel.Q) && AISearchIsEnabled())
{
var config = new AIConfiguration(ConfigurationManager.AppSettings["api-ai-key"], SupportedLanguage.English);
var apiAi = new ApiAi(config);
var response = apiAi.TextRequest(viewModel.Q);
if (response.Result.HasParameters)
{
viewModel.Q = String.Empty;
AddFacet(SearchFilterField.Color, response.Result.GetStringParameter(ApiAiEntity.Color), viewModel);
AddFacet(SearchFilterField.Brand, response.Result.GetStringParameter(ApiAiEntity.Brand), viewModel);
AddFacet(SearchFilterField.Gender, response.Result.GetStringParameter(ApiAiEntity.Gender), viewModel);
AddFacet(SearchFilterField.Category, response.Result.GetStringParameter(ApiAiEntity.Category), viewModel);
}
}
var customSearchResult = _searchService.Search(currentContent, viewModel);
viewModel.TotalCount = customSearchResult.TotalCount;
viewModel.FacetGroups = customSearchResult.FacetGroups.ToList();
viewModel.Sorting = _searchService.GetSortOrder().Select(x => new SelectListItem
{
Text = _localizationService.GetString("/Category/Sort/" + x.Name),
Value = x.Name.ToString(),
Selected = string.Equals(x.Name.ToString(), viewModel.Sort)
});
return(new SearchViewModel <T>
{
CurrentContent = currentContent,
ProductViewModels = customSearchResult.ProductViewModels,
FilterOption = viewModel
});
}
public async Task <ViewResult> Index(FashionNode currentContent, FilterOptionViewModel viewModel)
{
//vinhph Test
//var results = SearchClient.Instance.Search<VariationContent>().FilterOnCurrentMarket().GetContentResult();
//var result = SearchClient.Instance.Search<VariationContent>().Filter(x => x.DefaultPrice().UnitPrice.LessThan(new Money(2000000000, SiteContext.Current.Currency))).GetContentResult();
var model = _viewModelFactory.Create(currentContent, viewModel);
if (HttpContext.Request.HttpMethod == "GET")
{
var trackingResult = await _recommendationService.TrackCategoryAsync(HttpContext, currentContent);
model.Recommendations = trackingResult.GetCategoryRecommendations(_referenceConverter);
}
return(View(model));
}
private object ResolveQuickSearch(ResolveConnectionContext <object> context)
{
var viewModel = new FilterOptionViewModel
{
Page = ConnectionUtils.OffsetOrDefault(context.After, 0) / context.PageSize ?? 10,
PageSize = context.PageSize ?? 10,
Q = context.GetArgument <string>("query")
};
IEnumerable <ProductTileViewModel> products =
_searchService.QuickSearch(viewModel);
return(ConnectionUtils.ToConnection(
products,
context,
viewModel.Page * viewModel.PageSize,
viewModel.TotalCount));
}
public void Create_WhenSearching_ShouldSetTotalCountOnFormModel()
{
// Arrange
var formModel = new FilterOptionViewModel()
{
Q = "query"
};
_searchResultsMock
.Setup(s => s.TotalCount)
.Returns(666);
// Act
var result = _subject.Create <IContent>(null, formModel);
// Assert
Assert.Equal <int>(666, result.FilterOption.TotalCount);
}
public IEnumerable <ProductViewModel> QuickSearch(FilterOptionViewModel filterOptions)
{
if (String.IsNullOrEmpty(filterOptions.Q))
{
return(Enumerable.Empty <ProductViewModel>());
}
var criteria = CreateCriteriaForQuickSearch(filterOptions);
try
{
var searchResult = _search.Search(criteria);
return(CreateProductViewModels(searchResult));
}
catch (ParseException)
{
return(new ProductViewModel[0]);
}
}
public virtual SearchViewModel <TContent> Create <TContent>(TContent currentContent,
string selectedFacets,
int catalogId,
FilterOptionViewModel filterOption)
where TContent : IContent
{
var model = new SearchViewModel <TContent>(currentContent);
if (!filterOption.Q.IsNullOrEmpty() && (filterOption.Q.StartsWith("*") || filterOption.Q.StartsWith("?")))
{
model.CurrentContent = currentContent;
model.FilterOption = filterOption;
model.HasError = true;
model.ErrorMessage = _localizationService.GetString("/Search/BadFirstCharacter");
//model.CategoriesFilter = new CategoriesFilterViewModel();
return(model);
}
//var results = _searchService.Search(currentContent, filterOption, selectedFacets, catalogId);
var results = _searchService.SearchContent(filterOption);
model.ContentSearchResult = results;
filterOption.TotalCount = results.Hits.Count();
//filterOption.FacetGroups = results.FacetGroups.ToList();
//filterOption.Sorting = _searchService.GetSortOrder().Select(x => new SelectListItem
//{
// Text = _localizationService.GetString("/Category/Sort/" + x.Name),
// Value = x.Name.ToString(),
// Selected = string.Equals(x.Name.ToString(), filterOption.Sort)
//});
model.CurrentContent = currentContent;
//model.ProductViewModels = results?.ProductViewModels ?? new List<ProductTileViewModel>();
model.FilterOption = filterOption;
//model.CategoriesFilter = GetCategoriesFilter(currentContent, filterOption.Q);
//model.DidYouMeans = results.DidYouMeans;
model.Query = filterOption.Q;
//model.IsMobile = _httpContextBase.GetOverriddenBrowser().IsMobileDevice;
return(model);
}
public IEnumerable <ProductViewModel> QuickSearch(FilterOptionViewModel filterOptions)
{
if (String.IsNullOrEmpty(filterOptions.Q))
{
return(Enumerable.Empty <ProductViewModel>());
}
var searchClient = SearchClient.Instance.Search <FashionProduct>();
var pageSize = filterOptions.PageSize > 0 ? filterOptions.PageSize : _defaultPageSize;
var query = searchClient.For(filterOptions.Q)
.InAllField()
.PublishedInCurrentLanguage()
.Take(pageSize);
var results = query.GetContentResult();
return(CreateProductViewModels(results));
}
private CatalogEntrySearchCriteria CreateCriteriaForQuickSearch(FilterOptionViewModel filterOptions)
{
var sortOrder = GetSortOrder().FirstOrDefault(x => x.Name.ToString() == filterOptions.Sort) ?? GetSortOrder().First();
var market = _currentMarket.GetCurrentMarket();
var criteria = new CatalogEntrySearchCriteria
{
ClassTypes = new StringCollection {
"product"
},
Locale = _preferredCulture.Name,
MarketId = market.MarketId,
StartingRecord = 0,
RecordsToRetrieve = filterOptions.PageSize,
Sort = new SearchSort(new SearchSortField(sortOrder.Key, sortOrder.SortDirection == SortDirection.Descending)),
SearchPhrase = GetEscapedSearchPhrase(filterOptions.Q)
};
return(criteria);
}
public async Task <ViewResult> Index(GenericNode currentContent, FilterOptionViewModel viewModel)
{
if (string.IsNullOrEmpty(viewModel.ViewSwitcher))
{
viewModel.ViewSwitcher = string.IsNullOrEmpty(currentContent.DefaultTemplate) ? "Grid" : currentContent.DefaultTemplate;
}
var model = _viewModelFactory.Create(currentContent,
HttpContext.Request.QueryString["facets"],
0,
viewModel);
if (HttpContext.Request.HttpMethod == "GET")
{
var response = await _recommendationService.TrackCategory(HttpContext, currentContent);
model.Recommendations = response.GetCategoryRecommendations(_referenceConverter);
}
model.BreadCrumb = GetBreadCrumb(currentContent.Code);
return(View(model));
}
public virtual SearchViewModel <T> Create <T>(T currentContent, FilterOptionViewModel viewModel) where T : IContent
{
if (viewModel.Q != null && (viewModel.Q.StartsWith("*") || viewModel.Q.StartsWith("?")))
{
return(new SearchViewModel <T>
{
CurrentContent = currentContent,
FilterOption = viewModel,
HasError = true,
ErrorMessage = _localizationService.GetString("/Search/BadFirstCharacter"),
Recommendations = new List <Recommendation>()
});
}
var customSearchResult = _searchService.Search(currentContent, viewModel);
var totalResultCount = customSearchResult.SearchResult?.TotalCount ?? 0;
viewModel.TotalCount = totalResultCount;
viewModel.FacetGroups = customSearchResult.FacetGroups.ToList();
viewModel.Sorting = _searchService.GetSortOrder().Select(x => new SelectListItem
{
Text = _localizationService.GetString("/Category/Sort/" + x.Name),
Value = x.Name.ToString(),
Selected = string.Equals(x.Name.ToString(), viewModel.Sort)
});
return(new SearchViewModel <T>
{
CurrentContent = currentContent,
ProductViewModels = customSearchResult.ProductViewModels,
TotalResultCount = totalResultCount,
Facets = customSearchResult.SearchResult != null ? customSearchResult.SearchResult.FacetGroups : new ISearchFacetGroup[0],
FilterOption = viewModel,
Recommendations = new List <Recommendation>()
});
}
public void QuickSearch_ShouldReturnPopulatedProductViewModel()
{
var filterOptions = new FilterOptionViewModel();
filterOptions.Q = "query";
var result = _subject.QuickSearch(filterOptions);
var productViewModel = result.First();
var expected = new ProductTileViewModel
{
DisplayName = "DisplayName",
PlacedPrice = new Money(1, _currentCurrency),
DiscountedPrice = new Money(1, _currentCurrency),
ImageUrl = "/image.jpg",
Url = "http://domain.com",
Brand = "Brand",
Code = "Code",
IsAvailable = true
};
productViewModel.Should().BeEquivalentTo(expected);
}
private CatalogEntrySearchCriteria CreateDefaultCriteria(FilterOptionViewModel filterOptions)
{
var sortOrder = GetSortOrder().FirstOrDefault(x => x.Name.ToString() == filterOptions.Sort) ?? GetSortOrder().First();
var market = _currentMarket.GetCurrentMarket();
var criteria = new CatalogEntrySearchCriteria
{
ClassTypes = new StringCollection {
"product", "package", "bundle"
},
Locale = _languageResolver.GetPreferredCulture().Name,
MarketId = market.MarketId,
StartingRecord = 0,
RecordsToRetrieve = filterOptions.PageSize > 0 ? filterOptions.PageSize : _defaultPageSize,
Sort = new SearchSort(new SearchSortField(sortOrder.Key, sortOrder.SortDirection == SortDirection.Descending))
};
if (!string.IsNullOrEmpty(filterOptions.Q))
{
criteria.SearchPhrase = GetEscapedSearchPhrase(filterOptions.Q);
}
return(criteria);
}
public ActionResult Facet(SearchResultPage currentPage, FilterOptionViewModel viewModel) => PartialView("_Facet", viewModel);
public ActionResult Facet(FashionNode currentContent, FilterOptionViewModel viewModel)
{
return(PartialView("_Facet", viewModel));
}
public ViewResult Index(FashionNode currentContent, FilterOptionViewModel viewModel)
{
var model = _viewModelFactory.Create(currentContent, viewModel);
return(View(model));
}
private IEnumerable <FacetGroupOption> BuildFacetGroupList(IContent currentContent, FilterOptionViewModel filterOptions)
{
var query = BuildBaseQuery(currentContent, filterOptions);
query = query.Take(0);
query = query.TermsFacetFor(p => p.ParentName, r => r.Size = MaxNumberOfFacets);
query = query.TermsFacetFor(p => p.AvailableColorList, r => r.Size = MaxNumberOfFacets);
query = query.TermsFacetFor(p => p.AvailableSizeList, r => r.Size = MaxNumberOfFacets);
query = query.TermsFacetFor(p => p.Brand, r => r.Size = MaxNumberOfFacets);
query = query.TermsFacetFor(p => p.TopCategory, r => r.Size = MaxNumberOfFacets);
IContentResult <BaseProduct> results = query.GetContentResult();
var facetGroups = new List <FacetGroupOption>();
AddFacet(facetGroups, results.TermsFacetFor(p => p.ParentName),
filterOptions.FacetGroups.FirstOrDefault(fg => fg.GroupFieldName.Equals(Constants.Product.Categories)),
Constants.Product.Categories);
AddFacet(facetGroups, results.TermsFacetFor(p => p.AvailableColorList),
filterOptions.FacetGroups.FirstOrDefault(fg => fg.GroupFieldName.Equals(Constants.Product.AvailableColors)),
Constants.Product.AvailableColors);
AddFacet(facetGroups, results.TermsFacetFor(p => p.AvailableSizeList),
filterOptions.FacetGroups.FirstOrDefault(fg => fg.GroupFieldName.Equals(Constants.Product.AvailableSizes)),
Constants.Product.AvailableSizes);
AddFacet(facetGroups, results.TermsFacetFor(p => p.Brand),
filterOptions.FacetGroups.FirstOrDefault(fg => fg.GroupFieldName.Equals(Constants.Product.Brand)),
Constants.Product.Brand);
AddFacet(facetGroups, results.TermsFacetFor(p => p.TopCategory),
filterOptions.FacetGroups.FirstOrDefault(fg => fg.GroupFieldName.Equals(Constants.Product.TopCategory)),
Constants.Product.TopCategory);
return(facetGroups);
}
public ActionResult Index(SearchPage currentPage, FilterOptionViewModel filterOptions)
{
var viewModel = _viewModelFactory.Create(currentPage, filterOptions);
return(View(viewModel));
}
