public CodeSearchLink()
{
Page = 1;
PerPage = 20;
Sort = SearchSort.defaultsort;
}
public ForumSearchQuery SortBy(ForumTopicSorting sort)
{
switch (sort)
{
case ForumTopicSorting.SubjectAsc:
case ForumTopicSorting.SubjectDesc:
return(SortBy(SearchSort.ByStringField("subject", sort == ForumTopicSorting.SubjectDesc)));
case ForumTopicSorting.UserNameAsc:
case ForumTopicSorting.UserNameDesc:
return(SortBy(SearchSort.ByStringField("username", sort == ForumTopicSorting.UserNameDesc)));
case ForumTopicSorting.CreatedOnAsc:
case ForumTopicSorting.CreatedOnDesc:
return(SortBy(SearchSort.ByDateTimeField("createdon", sort == ForumTopicSorting.CreatedOnDesc)));
case ForumTopicSorting.PostsAsc:
case ForumTopicSorting.PostsDesc:
return(SortBy(SearchSort.ByIntField("numposts", sort == ForumTopicSorting.PostsDesc)));
case ForumTopicSorting.Relevance:
return(SortBy(SearchSort.ByRelevance()));
default:
return(this);
}
}
public SearchForm()
{
this.PageSize = DefaultPageSize;
this.Page = DefaultPage;
this.Sort = DefaultSort;
this.Tags = Array.Empty <string>();
}
public PSSearchSort(SearchSort sort)
{
if (sort != null)
{
this.Name = sort.Name;
this.Order = sort.Order;
}
}
public static string ToParamString(this SearchSort sort)
{
switch (sort)
{
case SearchSort.New:
return("date_desc");
case SearchSort.Popular:
return("popular_desc");
case SearchSort.Old:
return("date_asc");
default:
throw new ArgumentOutOfRangeException(nameof(sort), sort, null);
}
}
private SearchFaceResult SearchFace(string faceSetName, string image, ImageType imageType, int topN, double threshold,
SearchSort searchSort, SearchReturnFields searchReturnFields, string filter)
{
string uri = string.Format(FrsConstantV2.FACE_SEARCH_URI, projectId, faceSetName);
Dictionary <string, object> jsonObj = new Dictionary <string, object>();
switch (imageType)
{
case ImageType.BASE64:
jsonObj.Add("image_base64", image);
break;
case ImageType.URL:
jsonObj.Add("image_url", image);
break;
case ImageType.FACEID:
jsonObj.Add("face_id", image);
break;
}
if (-1 != topN)
{
jsonObj.Add("top_n", topN);
}
if (Math.Abs(threshold) > 0)
{
jsonObj.Add("threshold", threshold);
}
if (null != searchSort)
{
jsonObj.Add("sort", searchSort.GetString());
}
if (null != searchReturnFields)
{
jsonObj.Add("return_fields", searchReturnFields.GetString());
}
if (null != filter)
{
jsonObj.Add("filter", filter);
}
HttpWebResponse response = accessService.Post(uri, null, HttpUtils.ObjToData(jsonObj), FrsConstantV2.TYPE_JSON);
return(HttpUtils.ResponseToObj <SearchFaceResult>(response));
}
public virtual void Search(Action<IPagedList<Question>> onSuccess, Action<ApiException> onError = null, string inTitle = null, IEnumerable<string> tagged = null, IEnumerable<string> notTagged = null, SearchSort sortBy = SearchSort.Activity, SortDirection sortDirection = SortDirection.Descending, int? page = null, int? pageSize = null)
{
string taggedString = null;
if (tagged != null)
taggedString = String.Join(" ", tagged.ToArray());
string notTaggedString = null;
if (notTagged != null)
notTaggedString = String.Join(" ", notTagged.ToArray());
MakeRequest<QuestionResponse>("search", null, new
{
key = apiKey,
intitle = inTitle,
tagged = taggedString,
nottagged = notTaggedString,
sort = sortBy,
order = GetSortDirection(sortDirection),
page = page ?? null,
pagesize = pageSize ?? null
}, (items) => onSuccess(new PagedList<Question>(items.Questions, items)), onError);
}
protected void BindSearch()
{
int count = 0;
bool cacheResults = false;
TimeSpan cacheTimeout = new TimeSpan(0, 0, 1);
SearchSort sort = new SearchSort("TypeSort");
SearchFilterHelper filter = SearchFilterHelper.Current;
CatalogEntrySearchCriteria criteria = filter.CreateSearchCriteria(null, sort);
criteria.CatalogNames.Add("NWTD");
Entries entries = filter.SearchEntries(criteria, 0, 5, //ECF's API pads the results
out count,
new CatalogEntryResponseGroup(CatalogEntryResponseGroup.ResponseGroup.CatalogEntryInfo),
cacheResults, cacheTimeout
);
this.gvSearchResults.DataSource = entries.Entry;
this.gvSearchResults.DataBind();
}
public SearchFaceResult SearchFaceByFile(string faceSetName, string imagePath, int topN, double threshold,
SearchSort searchSort, SearchReturnFields searchReturnFields, string filter)
{
string uri = string.Format(FrsConstantV2.FACE_SEARCH_URI, this.projectId, faceSetName);
MultipartWriter multipart = new MultipartWriter();
multipart.WriteStart();
multipart.WriteFile("image_file", imagePath, imagePath);
//top n
if (-1 != topN)
{
multipart.WriteProperty("top_n", topN.ToString());
}
//threshold
if (Math.Abs(threshold) > 0)
{
multipart.WriteProperty("threshold", threshold.ToString());
}
//search sort
if (null != searchSort)
{
multipart.WriteProperty("sort", searchSort.GetString());
}
//return fields
if (null != searchReturnFields)
{
multipart.WriteProperty("return_fields", searchReturnFields.GetString());
}
//filter
if (null != filter)
{
multipart.WriteProperty("filter", filter);
}
byte[] data = multipart.WriteClose();
HttpWebResponse response = this.accessService.Post(uri, null, data, multipart.GetContentType());
return(HttpUtils.ResponseToObj <SearchFaceResult>(response));
}
public CatalogSearchQuery SortBy(ProductSortingEnum sort)
{
switch (sort)
{
case ProductSortingEnum.CreatedOnAsc:
case ProductSortingEnum.CreatedOn:
return(SortBy(SearchSort.ByDateTimeField("createdon", sort == ProductSortingEnum.CreatedOn)));
case ProductSortingEnum.NameAsc:
case ProductSortingEnum.NameDesc:
return(SortBy(SearchSort.ByStringField("name", sort == ProductSortingEnum.NameDesc)));
case ProductSortingEnum.PriceAsc:
case ProductSortingEnum.PriceDesc:
return(SortBy(SearchSort.ByDoubleField("price", sort == ProductSortingEnum.PriceDesc)));
case ProductSortingEnum.Relevance:
return(SortBy(SearchSort.ByRelevance()));
default:
return(this);
}
}
public virtual IPagedList<Question> Search(string inTitle = null, IEnumerable<string> tagged = null, IEnumerable<string> notTagged = null, SearchSort sortBy = SearchSort.Activity, SortDirection sortDirection = SortDirection.Descending, int? page = null, int? pageSize = null)
{
string taggedString = null;
if (tagged != null)
taggedString = String.Join(";", tagged);
string notTaggedString = null;
if (notTagged != null)
notTaggedString = String.Join(";", notTagged);
var response = MakeRequest<QuestionResponse>("search", null, new
{
key = apiKey,
intitle = inTitle,
tagged = taggedString,
nottagged = notTaggedString,
sort = sortBy,
order = GetSortDirection(sortDirection),
page = page ?? null,
pagesize = pageSize ?? null
});
return new PagedList<Question>(response.Questions, response);
}
/// <summary>
/// Creates the data model.
/// </summary>
/// <param name="criteria">The criteria.</param>
/// <param name="parameters">The parameters.</param>
/// <param name="cacheResults">if set to <c>true</c> [cache results].</param>
/// <returns>CatalogItemSearchModel.</returns>
private CatalogItemSearchModel CreateDataModel(CatalogItemSearchCriteria criteria, SearchParameters parameters,
bool cacheResults)
{
var session = UserHelper.CustomerSession;
// Create a model
var dataSource = new CatalogItemSearchModel();
// Now fill in filters
var filters = _searchFilter.Filters;
// Add all filters
foreach (var filter in filters)
{
criteria.Add(filter);
}
// Get selected filters
var facets = parameters.Facets;
dataSource.SelectedFilters = new List <SelectedFilterModel>();
if (facets.Count != 0)
{
foreach (var key in facets.Keys)
{
var filter = filters.SingleOrDefault(x => x.Key.Equals(key, StringComparison.OrdinalIgnoreCase) &&
(!(x is PriceRangeFilter) || ((PriceRangeFilter)x).Currency.Equals(StoreHelper.CustomerSession.Currency, StringComparison.OrdinalIgnoreCase)));
var appliedFilter = _searchFilter.Convert(filter, facets[key]);
foreach (var val in appliedFilter.GetValues())
{
criteria.Apply(appliedFilter);
dataSource.SelectedFilters.Add(
new SelectedFilterModel(_searchFilter.Convert(filter), _searchFilter.Convert(val)));
}
}
}
// Perform search
var sort = string.IsNullOrEmpty(parameters.Sort) ? "position" : parameters.Sort;
var sortOrder = parameters.SortOrder;
var isDescending = "desc".Equals(sortOrder, StringComparison.OrdinalIgnoreCase);
SearchSort sortObject = null;
switch (sort.ToLowerInvariant())
{
case "price":
if (session.Pricelists != null)
{
sortObject = new SearchSort(session.Pricelists.Select(priceList =>
new SearchSortField(
String.Format("price_{0}_{1}",
criteria.Currency.ToLower(),
priceList.ToLower()))
{
IgnoredUnmapped = true,
IsDescending = isDescending,
DataType = SearchSortField.DOUBLE
})
.ToArray());
}
break;
case "position":
sortObject = new SearchSort(new SearchSortField(string.Format("sort{0}{1}", session.CatalogId, session.CategoryId).ToLower())
{
IgnoredUnmapped = true,
IsDescending = isDescending
});
break;
case "name":
sortObject = new SearchSort("name", isDescending);
break;
case "rating":
sortObject = new SearchSort(criteria.ReviewsAverageField, isDescending);
break;
case "reviews":
sortObject = new SearchSort(criteria.ReviewsTotalField, isDescending);
break;
default:
sortObject = CatalogItemSearchCriteria.DefaultSortOrder;
break;
}
criteria.Sort = sortObject;
CatalogItemSearchResults results;
// Search using criteria, it will only return IDs of the items
var items = Search(criteria, cacheResults, out results).ToArray();
var itemsIdsArray = items.Select(i => i.ItemId).ToArray();
// Now load items with appropriate
var itemModelList = new List <CatalogItemWithPriceModel>();
if (items.Any())
{
// Now convert it to the model
var prices = _priceListClient.GetLowestPrices(session.Pricelists, itemsIdsArray, 1);
var availabilities = _catalogClient.GetItemAvailability(itemsIdsArray,
UserHelper.StoreClient.GetCurrentStore().FulfillmentCenterId);
foreach (var item in items)
{
PriceModel priceModel = null;
ItemAvailabilityModel availabilityModel = null;
var searchTags = results.Items[item.ItemId.ToLower()];
var currentOutline = this.GetItemOutlineUsingContext(searchTags[criteria.OutlineField].ToString());
//Cache outline
HttpContext.Items["browsingoutline_" + item.ItemId.ToLower()] = StripCatalogFromOutline(currentOutline);
if (prices != null && prices.Any())
{
var lowestPrice = (prices.Where(p => p.ItemId.Equals(item.ItemId, StringComparison.OrdinalIgnoreCase))).SingleOrDefault();
if (lowestPrice != null)
{
var tags = new Hashtable
{
{
"Outline",
currentOutline
}
};
priceModel = _marketing.GetItemPriceModel(item, lowestPrice, tags);
}
}
if (availabilities != null && availabilities.Any())
{
var availability =
(from a in availabilities
where a.ItemId.Equals(item.ItemId, StringComparison.OrdinalIgnoreCase)
select a).SingleOrDefault();
availabilityModel = new ItemAvailabilityModel(availability);
}
var itemModel = new CatalogItemWithPriceModel(CatalogHelper.CreateItemModel(item), priceModel, availabilityModel)
{
SearchOutline = currentOutline
};
try
{
itemModel.ItemReviewTotals.AverageRating = double.Parse(searchTags[criteria.ReviewsAverageField].ToString());
itemModel.ItemReviewTotals.TotalReviews = int.Parse(searchTags[criteria.ReviewsTotalField].ToString());
}
catch
{
//There are no reviews indexed?
}
itemModelList.Add(itemModel);
}
}
dataSource.FilterGroups = _searchFilter.Convert(results.FacetGroups);
dataSource.CatalogItems = itemModelList.ToArray();
dataSource.Criteria = criteria;
// Create pager
var pager = new PagerModel
{
TotalCount = results.TotalCount,
CurrentPage = criteria.StartingRecord / criteria.RecordsToRetrieve + 1,
RecordsPerPage = criteria.RecordsToRetrieve,
StartingRecord = criteria.StartingRecord,
DisplayStartingRecord = criteria.StartingRecord + 1,
SortValues = new[] { "Position", "Name", "Price", "Rating", "Reviews" },
SelectedSort = sort,
SortOrder = isDescending ? "desc" : "asc"
};
var end = criteria.StartingRecord + criteria.RecordsToRetrieve;
pager.DisplayEndingRecord = end > results.TotalCount ? results.TotalCount : end;
dataSource.Pager = pager;
return(dataSource);
}
public IHttpActionResult Search(string store, string[] priceLists, [ModelBinder(typeof(SearchParametersBinder))] SearchParameters parameters,
[FromUri] coreModel.ItemResponseGroup responseGroup = coreModel.ItemResponseGroup.ItemMedium,
[FromUri] string outline = "", string language = "en-us", string currency = "USD")
{
var context = new Dictionary <string, object>
{
{ "StoreId", store },
};
var fullLoadedStore = GetStoreById(store);
if (fullLoadedStore == null)
{
throw new NullReferenceException(store + " not found");
}
var catalog = fullLoadedStore.Catalog;
string categoryId = null;
var criteria = new CatalogIndexedSearchCriteria {
Locale = language, Catalog = catalog.ToLowerInvariant()
};
if (!string.IsNullOrWhiteSpace(outline))
{
criteria.Outlines.Add(String.Format("{0}/{1}*", catalog, outline));
categoryId = outline.Split(new[] { '/' }).Last();
context.Add("CategoryId", categoryId);
}
#region Filters
// Now fill in filters
var filters = _browseFilterService.GetFilters(context);
// Add all filters
foreach (var filter in filters)
{
criteria.Add(filter);
}
// apply terms
if (parameters.Terms != null && parameters.Terms.Count > 0)
{
foreach (var term in parameters.Terms)
{
var filter = filters.SingleOrDefault(x => x.Key.Equals(term.Key, StringComparison.OrdinalIgnoreCase) &&
(!(x is PriceRangeFilter) || ((PriceRangeFilter)x).Currency.Equals(currency, StringComparison.OrdinalIgnoreCase)));
var appliedFilter = _browseFilterService.Convert(filter, term.Value);
criteria.Apply(appliedFilter);
}
}
#endregion
#region Facets
// apply facet filters
var facets = parameters.Facets;
if (facets.Count != 0)
{
foreach (var key in facets.Select(f => f.Key))
{
var filter = filters.SingleOrDefault(
x => x.Key.Equals(key, StringComparison.OrdinalIgnoreCase) &&
(!(x is PriceRangeFilter) ||
((PriceRangeFilter)x).Currency.Equals(currency, StringComparison.OrdinalIgnoreCase)));
var appliedFilter = _browseFilterService.Convert(filter, facets.FirstOrDefault(f => f.Key == key).Value);
criteria.Apply(appliedFilter);
}
}
#endregion
//criteria.ClassTypes.Add("Product");
criteria.RecordsToRetrieve = parameters.PageSize == 0 ? 10 : parameters.PageSize;
criteria.StartingRecord = parameters.StartingRecord;
criteria.Pricelists = priceLists;
criteria.Currency = currency;
criteria.StartDateFrom = parameters.StartDateFrom;
criteria.SearchPhrase = parameters.FreeSearch;
#region sorting
if (!string.IsNullOrEmpty(parameters.Sort))
{
var isDescending = "desc".Equals(parameters.SortOrder, StringComparison.OrdinalIgnoreCase);
SearchSort sortObject = null;
switch (parameters.Sort.ToLowerInvariant())
{
case "price":
if (criteria.Pricelists != null)
{
sortObject = new SearchSort(
criteria.Pricelists.Select(
priceList =>
new SearchSortField(String.Format("price_{0}_{1}", criteria.Currency.ToLower(), priceList.ToLower()))
{
IgnoredUnmapped = true,
IsDescending = isDescending,
DataType = SearchSortField.DOUBLE
})
.ToArray());
}
break;
case "position":
sortObject =
new SearchSort(
new SearchSortField(string.Format("sort{0}{1}", catalog, categoryId).ToLower())
{
IgnoredUnmapped = true,
IsDescending = isDescending
});
break;
case "name":
sortObject = new SearchSort("name", isDescending);
break;
case "rating":
sortObject = new SearchSort(criteria.ReviewsAverageField, isDescending);
break;
case "reviews":
sortObject = new SearchSort(criteria.ReviewsTotalField, isDescending);
break;
default:
sortObject = CatalogIndexedSearchCriteria.DefaultSortOrder;
break;
}
criteria.Sort = sortObject;
}
#endregion
//Load ALL products
var searchResults = _browseService.SearchItems(criteria, responseGroup);
// populate inventory
if ((responseGroup & ItemResponseGroup.ItemProperties) == ItemResponseGroup.ItemProperties)
{
PopulateInventory(fullLoadedStore.FulfillmentCenter, searchResults.Items);
}
return(this.Ok(searchResults));
}
public SearchFaceResult SearchFaceByFaceId(string faceSetName, string faceId, int topN, double threshold,
SearchSort searchSort, SearchReturnFields searchReturnFields, string filter)
{
return(SearchFace(faceSetName, faceId, ImageType.FACEID, topN, threshold, searchSort, searchReturnFields, filter));
}
public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
{
if (bindingContext.ModelType != typeof(CatalogIndexedSearchCriteria))
{
return(false);
}
var key = actionContext.Request.RequestUri.Query;
var qs = HttpUtility.ParseQueryString(key);
var qsDict = this.NvToDict(qs);
// parse facets
var facets =
qsDict.Where(k => FacetRegex.IsMatch(k.Key))
.Select(k => k.WithKey(FacetRegex.Replace(k.Key, "")))
.ToDictionary(x => x.Key, y => y.Value.Split(','));
// parse facets
var terms =
qsDict.Where(k => TermRegex.IsMatch(k.Key))
.Select(k => k.WithKey(TermRegex.Replace(k.Key, "")))
.ToDictionary(x => x.Key, y => y.Value.Split(','));
var result = new CatalogIndexedSearchCriteria
{
SearchPhrase = qs["q"].EmptyToNull(),
RecordsToRetrieve = qs["take"].TryParse(20),
StartingRecord = qs["skip"].TryParse(0),
};
// apply filters if one specified
if (terms.Count > 0)
{
foreach (var term in terms)
{
var termFilter = new AttributeFilter
{
Key = term.Key.ToLowerInvariant(),
Values =
term.Value.Select(
x =>
new AttributeFilterValue()
{
Id = x.ToLowerInvariant(),
Value = x.ToLowerInvariant()
}).ToArray()
};
result.Apply(termFilter);
}
}
//result.ClassTypes.Add("Product");
var startDateFromStr = qs["startdatefrom"].EmptyToNull();
if (!string.IsNullOrWhiteSpace(startDateFromStr))
{
DateTime startDateFrom;
if (DateTime.TryParse(startDateFromStr, out startDateFrom))
{
result.StartDateFrom = startDateFrom;
}
}
//TODO load pricelists
result.Pricelists = null;
result.Currency = qs["curreny"].EmptyToNull();
var sortQuery = qs["sort"].EmptyToNull();
var sort = string.IsNullOrEmpty(sortQuery) ? "name" : sortQuery;
var sortOrder = qs["sortorder"].EmptyToNull();
var outline = qs["outline"].EmptyToNull();
var isDescending = "desc".Equals(sortOrder, StringComparison.OrdinalIgnoreCase);
var catalogId = actionContext.ActionArguments.ContainsKey("catalog")
? actionContext.ActionArguments["catalog"]
: null;
string categoryId = null;
if (!string.IsNullOrWhiteSpace(outline))
{
categoryId = outline.Split(new[] { '/' }).Last();
}
SearchSort sortObject = null;
switch (sort.ToLowerInvariant())
{
case "price":
if (result.Pricelists != null)
{
sortObject = new SearchSort(
result.Pricelists.Select(
priceList =>
new SearchSortField(
String.Format(
"price_{0}_{1}",
result.Currency.ToLower(),
priceList.ToLower()))
{
IgnoredUnmapped = true,
IsDescending = isDescending,
DataType = SearchSortField.DOUBLE
})
.ToArray());
}
break;
case "position":
sortObject =
new SearchSort(
new SearchSortField(string.Format("sort{0}{1}", catalogId, categoryId).ToLower())
{
IgnoredUnmapped = true,
IsDescending = isDescending
});
break;
case "name":
sortObject = new SearchSort("name", isDescending);
break;
case "rating":
sortObject = new SearchSort(result.ReviewsAverageField, isDescending);
break;
case "reviews":
sortObject = new SearchSort(result.ReviewsTotalField, isDescending);
break;
default:
sortObject = CatalogIndexedSearchCriteria.DefaultSortOrder;
break;
}
result.Sort = sortObject;
//Use fuzzy search to allow spelling error tolerance
result.IsFuzzySearch = true;
bindingContext.Model = result;
return(true);
}
public SearchFaceResult SearchFaceByBase64(string faceSetName, string imageBase64, int topN, double threshold,
SearchSort searchSort, SearchReturnFields searchReturnFields, string filter)
{
return(SearchFace(faceSetName, imageBase64, ImageType.BASE64, topN, threshold, searchSort, searchReturnFields, filter));
}
public SearchFaceResult SearchFaceByUrl(string faceSetName, string imageUrl, int topN, double threshold,
SearchSort searchSort, SearchReturnFields searchReturnFields, string filter)
{
return(SearchFace(faceSetName, imageUrl, ImageType.URL, topN, threshold, searchSort, searchReturnFields, filter));
}
public virtual void Search(Action <IPagedList <Question> > onSuccess, Action <ApiException> onError, string inTitle = null, IEnumerable <string> tagged = null, IEnumerable <string> notTagged = null, SearchSort sortBy = SearchSort.Activity, SortDirection sortDirection = SortDirection.Descending, int?page = null, int?pageSize = null)
{
string taggedString = null;
if (tagged != null)
{
taggedString = String.Join(" ", tagged.ToArray());
}
string notTaggedString = null;
if (notTagged != null)
{
notTaggedString = String.Join(" ", notTagged.ToArray());
}
MakeRequest <QuestionResponse>("search", null, new
{
key = apiKey,
intitle = inTitle,
tagged = taggedString,
nottagged = notTaggedString,
sort = sortBy,
order = GetSortDirection(sortDirection),
page = page ?? null,
pagesize = pageSize ?? null
}, (items) => onSuccess(new PagedList <Question>(items.Questions, items)), onError);
}
/// <summary>
/// Binds the results.
/// </summary>
private void BindResults(bool list)
{
SearchSort sortObject = CatalogEntrySearchCriteria.DefaultSortOrder;
//string sort = SortBy.SelectedValue;
//if (!String.IsNullOrEmpty(sort))
//{
// if (sort.Equals("name", StringComparison.OrdinalIgnoreCase))
// sortObject = new SearchSort("displayname");
// else if (sort.Equals("plh", StringComparison.OrdinalIgnoreCase))
// sortObject =
// new SearchSort(String.Format("saleprice{0}", SiteContext.Current.CurrencyCode).ToLower());
// else if (sort.Equals("phl", StringComparison.OrdinalIgnoreCase))
// sortObject =
// new SearchSort(String.Format("saleprice{0}", SiteContext.Current.CurrencyCode).ToLower(), true);
//}
var group = new CatalogEntryResponseGroup(CatalogEntryResponseGroup.ResponseGroup.CatalogEntryFull);
SearchFilterHelper helper = SearchFilterHelper.Current;
CatalogEntrySearchCriteria criteria = helper.CreateSearchCriteria("", sortObject);
//AddNodesToCriteria(criteria);
criteria.RecordsToRetrieve = 25;
criteria.StartingRecord = _startRowIndex;
criteria.ClassTypes.Add("Product");
var searchManager = new SearchManager(AppContext.Current.ApplicationName);
try
{
var results = searchManager.Search(criteria);
if (results == null)
{
return;
}
var resultIndexes = results.GetKeyFieldValues <int>();
var entries = CatalogContext.Current.GetCatalogEntries(resultIndexes, group);
if (entries.Entry != null)
{
var ds = CreateDataSource(entries, results.TotalCount);
if (!list)
{
EntriesList.DataSource = ds;
EntriesList.DataBind();
EntriesList.Visible = true;
listView.Visible = false;
}
else
{
listView.DataSource = ds;
listView.DataBind();
EntriesList.Visible = false;
listView.Visible = true;
}
if (results.TotalCount < 25)
{
DataPager3.Visible = false;
}
}
_filters = helper.SelectedFilters;
_facets = results.FacetGroups;
if (_filters != null && _filters.Length > 0)
{
ActiveFilterList.DataSource = _filters;
ActiveFilterList.DataBind();
ActiveFilterList.Visible = true;
}
else
{
ActiveFilterList.Visible = false;
}
if (_facets != null && _facets.Length > 0)
{
FilterList.Visible = true;
FilterList.DataSource = _facets;
FilterList.DataBind();
}
else
{
FilterList.Visible = false;
}
}
catch (Exception ex)
{
LogManager.GetLogger(GetType()).Error(ex.Message, ex);
}
}
/// <summary>
/// Binds the fields.
/// </summary>
private void BindFields()
{
int recordsToRetrieve = DataPager2.PageSize;
// Perform search
string keywords = Request.QueryString["search"];
int count = 0;
bool cacheResults = true;
TimeSpan cacheTimeout = new TimeSpan(0, 0, 30);
if (String.IsNullOrEmpty(keywords))
{
cacheTimeout = new TimeSpan(0, 1, 0);
}
SearchFilterHelper filter = SearchFilterHelper.Current;
string sort = Request.QueryString["s"];
SearchSort sortObject = null;
if (!String.IsNullOrEmpty(sort))
{
if (sort.Equals("name", StringComparison.OrdinalIgnoreCase))
{
sortObject = new SearchSort("DisplayName");
}
else if (sort.Equals("plh", StringComparison.OrdinalIgnoreCase))
{
sortObject = new SearchSort(String.Format("SalePrice{0}", CMSContext.Current.CurrencyCode));
}
else if (sort.Equals("phl", StringComparison.OrdinalIgnoreCase))
{
sortObject = new SearchSort(String.Format("SalePrice{0}", CMSContext.Current.CurrencyCode), true);
}
}
// Put default sort order if none is set
if (sortObject == null)
{
sortObject = CatalogEntrySearchCriteria.DefaultSortOrder;
}
CatalogEntrySearchCriteria criteria = filter.CreateSearchCriteria(keywords, sortObject);
if (_Parameters.Contains("Catalogs"))
{
foreach (string catalog in _Parameters["Catalogs"].ToString().Split(new char[',']))
{
if (!String.IsNullOrEmpty(catalog))
{
criteria.CatalogNames.Add(catalog);
}
}
}
if (_Parameters.Contains("NodeCode"))
{
foreach (string node in _Parameters["NodeCode"].ToString().Split(new char[',']))
{
if (!String.IsNullOrEmpty(node))
{
criteria.CatalogNodes.Add(node);
}
}
}
if (_Parameters.Contains("EntryClasses"))
{
foreach (string node in _Parameters["EntryClasses"].ToString().Split(new char[',']))
{
if (!String.IsNullOrEmpty(node))
{
criteria.SearchIndex.Add(node);
}
}
}
if (_Parameters.Contains("EntryTypes"))
{
foreach (string entry in _Parameters["EntryTypes"].ToString().Split(new char[',']))
{
if (!String.IsNullOrEmpty(entry))
{
criteria.ClassTypes.Add(entry);
}
}
}
if (_Parameters.Contains("RecordsPerPage"))
{
recordsToRetrieve = Int32.Parse(_Parameters["RecordsPerPage"].ToString());
}
// Bind default catalogs if none found
if (criteria.CatalogNames.Count == 0)
{
CatalogDto catalogs = CatalogContext.Current.GetCatalogDto(CMSContext.Current.SiteId);
if (catalogs.Catalog.Count > 0)
{
foreach (CatalogDto.CatalogRow row in catalogs.Catalog)
{
if (row.IsActive && row.StartDate <= FrameworkContext.Current.CurrentDateTime && row.EndDate >= FrameworkContext.Current.CurrentDateTime)
{
criteria.CatalogNames.Add(row.Name);
}
}
}
}
// No need to perform search if no catalogs specified
if (criteria.CatalogNames.Count != 0)
{
Entries entries = filter.SearchEntries(criteria, _StartRowIndex, recordsToRetrieve, out count, new CatalogEntryResponseGroup(CatalogEntryResponseGroup.ResponseGroup.CatalogEntryInfo), cacheResults, cacheTimeout);
CatalogSearchDataSource.TotalResults = count;
CatalogSearchDataSource.CatalogEntries = entries;
}
_Results = filter.Results;
if (count == 0)
{
PagingHeader.Visible = false;
PagingFooter.Visible = false;
DataPager2.Visible = false;
DataPager3.Visible = false;
MyMenu.Visible = false;
}
else
{
MyMenu.Filters = filter.SelectedFilters;
MyMenu.Facets = filter.GetFacets(cacheResults, cacheTimeout);
MyMenu.Visible = true;
//MyMenu.DataBind();
PagingHeader.Visible = true;
PagingFooter.Visible = true;
DataPager2.Visible = true;
DataPager3.Visible = true;
}
}
private Domain.Catalog.Model.SearchResult SearchProducts(Domain.Catalog.Model.SearchCriteria criteria)
{
var context = new Dictionary <string, object>
{
{ "StoreId", criteria.StoreId },
};
var catalog = criteria.CatalogId;
var categoryId = criteria.CategoryId;
var serviceCriteria = new CatalogIndexedSearchCriteria
{
Locale = criteria.LanguageCode,
Catalog = catalog.ToLowerInvariant(),
IsFuzzySearch = true,
};
if (!string.IsNullOrWhiteSpace(criteria.Outline))
{
serviceCriteria.Outlines.Add(string.Format(CultureInfo.InvariantCulture, "{0}/{1}*", catalog, criteria.Outline));
categoryId = criteria.Outline.Split('/').Last();
}
else
{
if (!string.IsNullOrEmpty(categoryId))
{
serviceCriteria.Outlines.Add(string.Format(CultureInfo.InvariantCulture, "{0}/{1}*", catalog, categoryId));
}
}
if (!string.IsNullOrEmpty(categoryId))
{
context.Add("CategoryId", categoryId);
}
#region Filters
// Now fill in filters
var filters = _cacheManager.Get("GetFilters-" + criteria.StoreId, "SearchProducts", TimeSpan.FromMinutes(5), () => _browseFilterService.GetFilters(context));
// Add all filters
foreach (var filter in filters)
{
serviceCriteria.Add(filter);
}
// apply terms
var terms = ParseKeyValues(criteria.Terms);
if (terms.Any())
{
var filtersWithValues = filters
.Where(x => (!(x is PriceRangeFilter) || ((PriceRangeFilter)x).Currency.Equals(criteria.Currency, StringComparison.OrdinalIgnoreCase)))
.Select(x => new { Filter = x, Values = x.GetValues() })
.ToList();
foreach (var term in terms)
{
var filter = filters.SingleOrDefault(x => x.Key.Equals(term.Key, StringComparison.OrdinalIgnoreCase) &&
(!(x is PriceRangeFilter) || ((PriceRangeFilter)x).Currency.Equals(criteria.Currency, StringComparison.OrdinalIgnoreCase)));
// handle special filter term with a key = "tags", it contains just values and we need to determine which filter to use
if (filter == null && term.Key == "tags")
{
foreach (var termValue in term.Values)
{
// try to find filter by value
var foundFilter = filtersWithValues.FirstOrDefault(x => x.Values.Any(y => y.Id.Equals(termValue)));
if (foundFilter != null)
{
filter = foundFilter.Filter;
var appliedFilter = _browseFilterService.Convert(filter, term.Values);
serviceCriteria.Apply(appliedFilter);
}
}
}
else
{
var attributeFilter = filter as AttributeFilter;
if (attributeFilter != null && attributeFilter.Values == null)
{
var dynamicValues = new List <AttributeFilterValue>();
foreach (var value in term.Values)
{
dynamicValues.Add(new AttributeFilterValue()
{
Id = value,
Value = value
});
}
attributeFilter.Values = dynamicValues.ToArray();
}
var appliedFilter = _browseFilterService.Convert(filter, term.Values);
serviceCriteria.Apply(appliedFilter);
}
}
}
#endregion
#region Facets
// apply facet filters
var facets = ParseKeyValues(criteria.Facets);
foreach (var facet in facets)
{
var filter = filters.SingleOrDefault(
x => x.Key.Equals(facet.Key, StringComparison.OrdinalIgnoreCase) &&
(!(x is PriceRangeFilter) ||
((PriceRangeFilter)x).Currency.Equals(criteria.Currency, StringComparison.OrdinalIgnoreCase)));
var appliedFilter = _browseFilterService.Convert(filter, facet.Values);
serviceCriteria.Apply(appliedFilter);
}
#endregion
//criteria.ClassTypes.Add("Product");
serviceCriteria.RecordsToRetrieve = criteria.Take < 0 ? 10 : criteria.Take;
serviceCriteria.StartingRecord = criteria.Skip;
serviceCriteria.Pricelists = criteria.PricelistIds;
serviceCriteria.Currency = criteria.Currency;
serviceCriteria.StartDateFrom = criteria.StartDateFrom;
serviceCriteria.SearchPhrase = criteria.Keyword;
#region sorting
if (!criteria.SortInfos.IsNullOrEmpty())
{
var sortInfo = criteria.SortInfos.FirstOrDefault();
var isDescending = sortInfo.SortDirection == SortDirection.Descending;
SearchSort sortObject = null;
switch (sortInfo.SortColumn.ToLowerInvariant())
{
case "price":
if (serviceCriteria.Pricelists != null)
{
sortObject = new SearchSort(
serviceCriteria.Pricelists.Select(
priceList =>
new SearchSortField(string.Format("price_{0}_{1}", serviceCriteria.Currency.ToLower(), priceList.ToLower()))
{
IgnoredUnmapped = true,
IsDescending = isDescending,
DataType = SearchSortField.DOUBLE
})
.ToArray());
}
break;
case "position":
sortObject =
new SearchSort(
new SearchSortField(string.Concat("sort", catalog, categoryId).ToLower())
{
IgnoredUnmapped = true,
IsDescending = isDescending
});
break;
case "name":
case "title":
sortObject = new SearchSort("name", isDescending);
break;
case "rating":
sortObject = new SearchSort(serviceCriteria.ReviewsAverageField, isDescending);
break;
case "reviews":
sortObject = new SearchSort(serviceCriteria.ReviewsTotalField, isDescending);
break;
default:
sortObject = CatalogIndexedSearchCriteria.DefaultSortOrder;
break;
}
serviceCriteria.Sort = sortObject;
}
#endregion
var responseGroup = ItemResponseGroup.ItemInfo | ItemResponseGroup.ItemAssets | ItemResponseGroup.Seo;
if ((criteria.ResponseGroup & SearchResponseGroup.WithProperties) == SearchResponseGroup.WithProperties)
{
responseGroup |= ItemResponseGroup.ItemProperties;
}
if ((criteria.ResponseGroup & SearchResponseGroup.WithVariations) == SearchResponseGroup.WithVariations)
{
responseGroup |= ItemResponseGroup.Variations;
}
//Load ALL products
var searchResults = _browseService.SearchItems(serviceCriteria, responseGroup);
//// populate inventory
////if ((request.ResponseGroup & ItemResponseGroup.ItemProperties) == ItemResponseGroup.ItemProperties)
//if ((criteria.ResponseGroup & SearchResponseGroup.WithProperties) == SearchResponseGroup.WithProperties)
//{
// PopulateInventory(store.FulfillmentCenter, searchResults.Products);
//}
return(searchResults);
}
/// <summary>
/// Searches the entries.
/// </summary>
/// <param name="keywords">The keywords.</param>
/// <param name="sort">The sort.</param>
/// <param name="startIndex">The start index.</param>
/// <param name="recordsToRetrieve">The records to retrieve.</param>
/// <param name="count">The count.</param>
/// <param name="responseGroup">The response group.</param>
/// <param name="cacheResults">if set to <c>true</c> [cache results].</param>
/// <param name="cacheTimeout">The cache timeout.</param>
/// <returns></returns>
public virtual Entries SearchEntries(string keywords, SearchSort sort, int startIndex, int recordsToRetrieve, out int count, CatalogEntryResponseGroup responseGroup, bool cacheResults, TimeSpan cacheTimeout)
{
CatalogEntrySearchCriteria criteria = CreateSearchCriteria(keywords, sort);
return(SearchEntries(criteria, startIndex, recordsToRetrieve, out count, responseGroup, cacheResults, cacheTimeout));
}
/// <summary>
/// Searches the entries.
/// </summary>
/// <param name="keywords">The keywords.</param>
/// <param name="sort">The sort.</param>
/// <returns></returns>
public virtual SearchResults SearchEntries(string keywords, SearchSort sort)
{
CatalogEntrySearchCriteria criteria = CreateSearchCriteria(keywords, sort);
return(SearchEntries(criteria));
}
/// <summary>
/// Creates the search criteria.
/// </summary>
/// <param name="keywords">The keywords.</param>
/// <param name="sort">The sort.</param>
/// <returns></returns>
public CatalogEntrySearchCriteria CreateSearchCriteria(string keywords, SearchSort sort)
{
NameValueCollection querystring = HttpContext.Current.Request.QueryString;
string currentNodeCode = querystring["nc"];
CatalogEntrySearchCriteria criteria = new CatalogEntrySearchCriteria();
if (!String.IsNullOrEmpty(currentNodeCode))
{
criteria.CatalogNodes.Add(currentNodeCode);
// Include all the sub nodes in our search results
CatalogDto catalogs = CatalogContext.Current.GetCatalogDto(CMSContext.Current.SiteId);
foreach (CatalogDto.CatalogRow catalog in catalogs.Catalog)
{
CatalogNodes nodes = CatalogContext.Current.GetCatalogNodes(catalog.Name, querystring["nc"]);
if (nodes.CatalogNode != null && nodes.CatalogNode.Length > 0)
{
foreach (CatalogNode nodeRow in nodes.CatalogNode)
{
criteria.CatalogNodes.Add(nodeRow.ID);
}
}
}
}
criteria.SearchPhrase = keywords;
criteria.SearchIndex.Add(querystring["filter"]);
criteria.Sort = sort;
// Add all filters
foreach (SearchFilter filter in SearchConfig.SearchFilters)
{
// Check if we already filtering
if (querystring.Get(filter.field) != null)
{
continue;
}
criteria.Add(filter);
}
// Get selected filters
SelectedFilter[] filters = SelectedFilters;
if (filters.Length != 0)
{
foreach (SelectedFilter filter in filters)
{
if (filter.PriceRangeValue != null)
{
criteria.Add(filter.Filter.field, filter.PriceRangeValue);
}
if (filter.RangeValue != null)
{
criteria.Add(filter.Filter.field, filter.RangeValue);
}
if (filter.SimpleValue != null)
{
criteria.Add(filter.Filter.field, filter.SimpleValue);
}
}
}
return(criteria);
}
public static void DemoV2()
{
// Use FrsClient::GetV2() to get v2 api
AuthInfo authInfo = new AuthInfo("https://face.cn-north-1.myhuaweicloud.com", "ak", "sk");
FrsClient frsClient = new FrsClient(authInfo, "project id");
try
{
Console.WriteLine("compare");
CompareFaceResult compareFaceResult = frsClient.GetV2().GetCompareService().CompareFaceByUrl("/obs/1.jpg", "/obs/1.jpg");
Console.WriteLine(compareFaceResult.GetJsonString());
compareFaceResult = frsClient.GetV2().GetCompareService().CompareFaceByFile("/resource/1.jpeg", "/resource/1.jpeg");
Console.WriteLine(compareFaceResult.GetJsonString());
Console.WriteLine("detect");
DetectFaceResult detectFaceResult = frsClient.GetV2().GetDetectService().DetectFaceByUrl("/obs/1.jpg", "0,1,2");
Console.WriteLine(detectFaceResult.GetJsonString());
DetectFaceResult detectFaceResult2 = frsClient.GetV2().GetDetectService().DetectFaceByFile("/resource/1.jpeg", "1,2");
Console.WriteLine(detectFaceResult2.GetJsonString());
Console.WriteLine("live detect");
LiveDetectResult liveDetectResult = frsClient.GetV2().GetLiveDetectService().LiveDetectByUrl("/obs/1.jpg", "1", "0-1000");
Console.WriteLine(liveDetectResult.GetJsonString());
liveDetectResult = frsClient.GetV2().GetLiveDetectService().LiveDetectByFile("/resource/3.png", "1");
Console.WriteLine(liveDetectResult.GetJsonString());
Console.WriteLine("create face set");
//CreateFaceSetResult createFaceSetResult = frsClient.GetFaceSetService().CreateFaceSet("face_set_name_test");
//Console.WriteLine(createFaceSetResult.GetJsonString());
CreateExternalFields createExternalFields = new CreateExternalFields();
createExternalFields.AddField("testInt", FieldType.INTEGER);
createExternalFields.AddField("testStr", FieldType.STRING);
CreateFaceSetResult createFaceSetResult = frsClient.GetV2().GetFaceSetService().CreateFaceSet("face_set_name_test", 10000, createExternalFields);
Console.WriteLine(createFaceSetResult.GetJsonString());
Console.WriteLine("get all face set");
GetAllFaceSetsResult getAllFaceSetsResult = frsClient.GetV2().GetFaceSetService().GetAllFaceSets();
Console.WriteLine(getAllFaceSetsResult.GetJsonString());
Console.WriteLine("get face set");
GetFaceSetResult getFaceSetResult = frsClient.GetV2().GetFaceSetService().GetFaceSet("face_set_name_test");
Console.WriteLine(getFaceSetResult.GetJsonString());
Console.WriteLine("add face");
AddFaceResult addFaceResult = frsClient.GetV2().GetFaceService().AddFaceByUrl("face_set_name_test", "/obs/1.jpg");
Console.WriteLine(addFaceResult.GetJsonString());
AddExternalFields addExternalFields = new AddExternalFields();
addExternalFields.AddField("testInt", 1);
addExternalFields.AddField("testStr", "str");
addFaceResult = frsClient.GetV2().GetFaceService().AddFaceByFile("face_set_name_test", "/resource/3.png", addExternalFields);
Console.WriteLine(addFaceResult.GetJsonString());
Console.WriteLine("get all face");
GetFaceResult getFaceResult = frsClient.GetV2().GetFaceService().GetFaces("face_set_name_test", 0, 10);
Console.WriteLine(getFaceResult.GetJsonString());
Console.WriteLine("search face");
SearchFaceResult searchFaceResult = frsClient.GetV2().GetSearchService().SearchFaceByFile("face_set_name_test", "/resource/3.png", 10, 0.1);
Console.WriteLine(searchFaceResult.GetJsonString());
SearchSort searchSort = new SearchSort();
searchSort.AddSortField("testInt", SortType.ASC);
SearchReturnFields searchReturnFields = new SearchReturnFields();
searchReturnFields.AddReturnField("testInt");
searchFaceResult = frsClient.GetV2().GetSearchService().SearchFaceByUrl("face_set_name_test", "/obs/1.jpg", 10, 0, searchSort, searchReturnFields, null);
Console.WriteLine(searchFaceResult.GetJsonString());
Console.WriteLine("delete face set");
DeleteFaceSetResult deleteFaceSetResult = frsClient.GetV2().GetFaceSetService().DeleteFaceSet("face_set_name_test");
Console.WriteLine(deleteFaceSetResult.GetJsonString());
}
catch (Exception e)
{
Console.WriteLine("=======ERROR CLEAN==========");
DeleteFaceSetResult deleteFaceSetResult = frsClient.GetV2().GetFaceSetService().DeleteFaceSet("face_set_name_test");
Console.WriteLine(deleteFaceSetResult.GetJsonString());
Console.WriteLine(e);
}
}
public IHttpActionResult Search([FromUri] ProductSearchRequest request)
{
request = request ?? new ProductSearchRequest();
request.Normalize();
var context = new Dictionary <string, object>
{
{ "StoreId", request.Store },
};
var fullLoadedStore = GetStoreById(request.Store);
if (fullLoadedStore == null)
{
throw new NullReferenceException(request.Store + " not found");
}
var catalog = fullLoadedStore.Catalog;
string categoryId = null;
var criteria = new CatalogIndexedSearchCriteria {
Locale = request.Language, Catalog = catalog.ToLowerInvariant(), IsFuzzySearch = true
};
if (!string.IsNullOrWhiteSpace(request.Outline))
{
criteria.Outlines.Add(string.Format("{0}/{1}*", catalog, request.Outline));
categoryId = request.Outline.Split(new[] { '/' }).Last();
context.Add("CategoryId", categoryId);
}
#region Filters
// Now fill in filters
var filters = _browseFilterService.GetFilters(context);
// Add all filters
foreach (var filter in filters)
{
criteria.Add(filter);
}
// apply terms
var terms = ParseKeyValues(request.Terms);
if (terms.Any())
{
var filtersWithValues = filters
.Where(x => (!(x is PriceRangeFilter) || ((PriceRangeFilter)x).Currency.Equals(request.Currency, StringComparison.OrdinalIgnoreCase)))
.Select(x => new { Filter = x, Values = x.GetValues() })
.ToList();
foreach (var term in terms)
{
var filter = filters.SingleOrDefault(x => x.Key.Equals(term.Key, StringComparison.OrdinalIgnoreCase) &&
(!(x is PriceRangeFilter) || ((PriceRangeFilter)x).Currency.Equals(request.Currency, StringComparison.OrdinalIgnoreCase)));
// handle special filter term with a key = "tags", it contains just values and we need to determine which filter to use
if (filter == null && term.Key == "tags")
{
foreach (var termValue in term.Values)
{
// try to find filter by value
var foundFilter = filtersWithValues.FirstOrDefault(x => x.Values.Any(y => y.Id.Equals(termValue)));
if (foundFilter != null)
{
filter = foundFilter.Filter;
var appliedFilter = _browseFilterService.Convert(filter, term.Values);
criteria.Apply(appliedFilter);
}
}
}
else
{
var appliedFilter = _browseFilterService.Convert(filter, term.Values);
criteria.Apply(appliedFilter);
}
}
}
#endregion
#region Facets
// apply facet filters
var facets = ParseKeyValues(request.Facets);
foreach (var facet in facets)
{
var filter = filters.SingleOrDefault(
x => x.Key.Equals(facet.Key, StringComparison.OrdinalIgnoreCase) &&
(!(x is PriceRangeFilter) ||
((PriceRangeFilter)x).Currency.Equals(request.Currency, StringComparison.OrdinalIgnoreCase)));
var appliedFilter = _browseFilterService.Convert(filter, facet.Values);
criteria.Apply(appliedFilter);
}
#endregion
//criteria.ClassTypes.Add("Product");
criteria.RecordsToRetrieve = request.Take <= 0 ? 10 : request.Take;
criteria.StartingRecord = request.Skip;
criteria.Pricelists = request.Pricelists;
criteria.Currency = request.Currency;
criteria.StartDateFrom = request.StartDateFrom;
criteria.SearchPhrase = request.SearchPhrase;
#region sorting
if (!string.IsNullOrEmpty(request.Sort))
{
var isDescending = "desc".Equals(request.SortOrder, StringComparison.OrdinalIgnoreCase);
SearchSort sortObject = null;
switch (request.Sort.ToLowerInvariant())
{
case "price":
if (criteria.Pricelists != null)
{
sortObject = new SearchSort(
criteria.Pricelists.Select(
priceList =>
new SearchSortField(String.Format("price_{0}_{1}", criteria.Currency.ToLower(), priceList.ToLower()))
{
IgnoredUnmapped = true,
IsDescending = isDescending,
DataType = SearchSortField.DOUBLE
})
.ToArray());
}
break;
case "position":
sortObject =
new SearchSort(
new SearchSortField(string.Format("sort{0}{1}", catalog, categoryId).ToLower())
{
IgnoredUnmapped = true,
IsDescending = isDescending
});
break;
case "name":
sortObject = new SearchSort("name", isDescending);
break;
case "rating":
sortObject = new SearchSort(criteria.ReviewsAverageField, isDescending);
break;
case "reviews":
sortObject = new SearchSort(criteria.ReviewsTotalField, isDescending);
break;
default:
sortObject = CatalogIndexedSearchCriteria.DefaultSortOrder;
break;
}
criteria.Sort = sortObject;
}
#endregion
//Load ALL products
var searchResults = _browseService.SearchItems(criteria, request.ResponseGroup);
// populate inventory
if ((request.ResponseGroup & ItemResponseGroup.ItemProperties) == ItemResponseGroup.ItemProperties)
{
PopulateInventory(fullLoadedStore.FulfillmentCenter, searchResults.Items);
}
return(Ok(searchResults));
}
public virtual IPagedList <Question> Search(string inTitle = null, IEnumerable <string> tagged = null, IEnumerable <string> notTagged = null, SearchSort sortBy = SearchSort.Activity, SortDirection sortDirection = SortDirection.Descending, int?page = null, int?pageSize = null)
{
string taggedString = null;
if (tagged != null)
{
taggedString = String.Join(";", tagged);
}
string notTaggedString = null;
if (notTagged != null)
{
notTaggedString = String.Join(";", notTagged);
}
var response = MakeRequest <QuestionResponse>("search", null, new
{
key = apiKey,
intitle = inTitle,
tagged = taggedString,
nottagged = notTaggedString,
sort = sortBy,
order = GetSortDirection(sortDirection),
page = page ?? null,
pagesize = pageSize ?? null
});
return(new PagedList <Question>(response.Questions, response));
}
public CodeSearchLink()
{
Page = 1;
PerPage = 20;
Sort = SearchSort.defaultsort;
}
