public async Task <ProductSearchResult> SearchProducts([FromQuery] ProductSearchCriteria criteria)
{
return(await _productQueryService.SearchAsync(criteria));
}
protected virtual IList <KeyValuePair <string, IFilter> > GetRemovableFilters(ProductSearchCriteria criteria, IList <IFilter> permanentFilters)
{
var result = new List <KeyValuePair <string, IFilter> >();
var terms = criteria.GetTerms();
if (terms.Any())
{
var browseFilters = GetBrowseFilters(criteria);
var filtersAndValues = browseFilters
?.Select(x => new { Filter = x, Values = x.GetValues() })
.ToList();
foreach (var term in terms)
{
var browseFilter = browseFilters?.SingleOrDefault(x => x.Key.EqualsInvariant(term.Key));
// Handle special filter term with a key = "tags", it contains just values and we need to determine which filter to use
if (browseFilter == null && term.Key == "tags")
{
foreach (var termValue in term.Values)
{
// Try to find filter by value
var filterAndValues = filtersAndValues?.FirstOrDefault(x => x.Values.Any(y => y.Id.Equals(termValue)));
if (filterAndValues != null)
{
var filter = ConvertBrowseFilter(filterAndValues.Filter, term.Values, criteria);
permanentFilters.Add(filter);
}
else
{
// Unknown term values should produce empty result
permanentFilters.Add(new IdsFilter {
Values = new[] { string.Empty }
});
}
}
}
else if (browseFilter != null) // Predefined filter
{
var filter = ConvertBrowseFilter(browseFilter, term.Values, criteria);
result.Add(new KeyValuePair <string, IFilter>(browseFilter.Key, filter));
}
else // Custom term
{
var filter = FiltersHelper.CreateTermFilter(term.Key, term.Values);
permanentFilters.Add(filter);
}
}
}
return(result);
}
protected virtual IFilter ConvertPriceRangeFilter(PriceRangeFilter priceRangeFilter, IList <string> valueIds, ProductSearchCriteria criteria)
{
IFilter result = null;
if (string.IsNullOrEmpty(criteria.Currency) || priceRangeFilter.Currency.EqualsInvariant(criteria.Currency))
{
var knownValues = priceRangeFilter.Values
?.Where(v => valueIds.Contains(v.Id, StringComparer.OrdinalIgnoreCase))
.ToArray();
if (knownValues != null && knownValues.Any())
{
var filters = knownValues
.Select(v => FiltersHelper.CreatePriceRangeFilter(priceRangeFilter.Currency, criteria.Pricelists, v.Lower, v.Upper, v.IncludeLower, v.IncludeUpper))
.Where(f => f != null)
.ToList();
result = filters.Or();
}
else
{
// Unknown term values should produce empty result
result = new IdsFilter {
Values = new[] { string.Empty }
};
}
}
return(result);
}
private void BuildGoogleFeed()
{
//
// the majority of the code to follow is based upon the excellent blog below:
// http://blog.codenamed.nl/2015/05/14/creating-a-google-shopping-feed-with-c/
//
// get an instance of the store application
var HccApp = HotcakesApplication.Current;
var totalProducts = 0;
var feed = new FeedInfo();
// get the store URL based upon SSL
var storeUrl = Request.IsSecureConnection ? HccApp.CurrentStore.RootUrlSecure() : HccApp.CurrentStore.RootUrl();
// used to get currency code
var regionInfo = new RegionInfo(System.Threading.Thread.CurrentThread.CurrentUICulture.LCID);
feed.Link = storeUrl;
feed.Title = HccApp.CurrentStore.StoreName;
feed.Updated = DateTime.Now;
feed.Entries = new List <EntryInfo>();
// find all products in the store that are active
var searchCriteria = new ProductSearchCriteria
{
DisplayInactiveProducts = false
};
// using the search instead of querying the Products directly to use cache
var products = HccApp.CatalogServices.Products.FindByCriteria(searchCriteria, 1, int.MaxValue, ref totalProducts);
// non-shipping
var shippingInfo = new ShippingInfo {
Price = Constants.HARDCODED_PRICE_ZERO
};
// not taxable (e.g., software)
var taxInfo = new TaxInfo {
Rate = Constants.HARDCODED_PRICE_ZERO
};
// iterate through each product and add it to the feed
foreach (var product in products)
{
var productUrl = UrlRewriter.BuildUrlForProduct(product);
var productEntry = new EntryInfo
{
Availablity = GetStockMessage(product), // OPTIONS: preorder, in stock, out of stock
Condition = Constants.CONDITION_NEW, // OPTIONS: new, refurbished, used
Description = product.LongDescription,
GoogleProductCategory = Constants.HARDCODED_GOOGLE_CATEGORY, // hard-coded for this example project (see property attributes)
Id = product.Sku,
ImageLink = DiskStorage.ProductImageUrlMedium(HccApp, product.Bvin, product.ImageFileMedium, Request.IsSecureConnection),
Link = productUrl,
MobileLink = productUrl,
Price = string.Format(Constants.CURRENCY_TEXT_FORMAT, product.SitePrice.ToString(Constants.CURRENCY_FORMAT), regionInfo.ISOCurrencySymbol),
ProductType = GetFirstAvailableCategory(HccApp, product.Bvin), // put your preferred site category here
Title = product.ProductName,
MPN = product.Sku, // this should be replaced with real data
Brand = product.VendorId, // this should be replaced with real data
Color = string.Empty,
Gender = Constants.GENDER_UNISEX, // OPTIONS: male, female, unisex
AgeGroup = Constants.AGE_GROUP_ADULT, // OPTIONS: newborn, infant, toddler, kids, adult
GTIN = GenerateGTIN() // this should be replaced with real data
};
// this could and should be iterated on to show shipping options for up to 100 locations
productEntry.Shipping = new List <ShippingInfo>();
productEntry.Shipping.Add(shippingInfo);
// this could and should be iterated on to show taxes for up to 100 locations
productEntry.Tax = new List <TaxInfo>();
productEntry.Tax.Add(taxInfo);
feed.Entries.Add(productEntry);
}
// simply done to display the feed in the textbox
// alternatives could be to send this through a web service or other means
txtGoogleFeed.Text = feed.SerializeObject();
}
/// <summary>
/// Async search products by given criteria
/// </summary>
/// <param name="criteria"></param>
/// <returns></returns>
public virtual async Task <CatalogSearchResult> SearchProductsAsync(ProductSearchCriteria criteria)
{
var workContext = _workContextAccessor.WorkContext;
return(await InnerSearchProductsAsync(criteria, workContext));
}
public static searchDto.ProductSearch ToProductSearchDto(this ProductSearchCriteria criteria, WorkContext workContext)
{
return(CatalogConverterInstance.ToProductSearchDto(criteria, workContext));
}
static void Main(string[] args)
{
// CreateOrderTest();
ContextFactory contextFactory = new ContextFactory();
ShopContext context = contextFactory.CreateDbContext(args);
context.Database.Migrate();
if (!context.Products.Any())
{
CreateSampleData(context);
}
for (int i = 2; i < 10; i++)
{
CreateOrder(context, $"ZA {i}");
}
var updateproducts = context.Products.OrderBy(p => p.Id).Take(10).ToList();
context.Products.RemoveRange(updateproducts);
context.SaveChanges();
var product = context.Products.First();
Console.WriteLine(context.Entry(product).State);
product.UnitPrice = 400.00m;
product.Color = "red";
Console.WriteLine(context.Entry(product).State);
product.UnitPrice = 300.00m;
Console.WriteLine(context.Entry(product).State);
Console.WriteLine(context.Entry(product).Property(p => p.UnitPrice).OriginalValue);
context.SaveChanges();
Console.WriteLine(context.Entry(product).State);
// context.Products.Remove(product);
Console.WriteLine(context.Entry(product).State);
context.Entry(product).State = EntityState.Unchanged;
context.SaveChanges();
IProductsService productsService = new DbProductsService(context);
productsService.Remove(20);
ProductSearchCriteria searchCriteria = new ProductSearchCriteria
{
};
var colorProducts = productsService.Get(searchCriteria);
if (colorProducts.Any())
{
}
// context.Database.EnsureDeleted();
// context.Database.EnsureCreated();
context.Database.Migrate();
var customers = context.Customers.ToList();
var products = context.Products
.Where(p => p.UnitPrice > 100)
.Where(p => p.Name.StartsWith("N"))
.OrderBy(p => p.Name)
.ThenBy(p => p.Color)
.Select(p => new { p.Name, p.Color })
.ToList();
var productsByColor = context.Products
.GroupBy(p => p.Color)
.ToList();
var productsQtyByColor = context.Products
.GroupBy(p => p.Color)
.Select(g => new { Color = g.Key, Qty = g.Count() })
.ToList();
//var productsOver100 = new List<Product>();
//foreach (var product in context.Products)
//{
// if (product.UnitPrice > 100)
// {
// productsOver100.Add(product);
// }
//}
// string customers = configuration["Generator:Customers"];
// Generowanie danych
// CreateSampleData(context);
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
var tuple = GetTuple2();
}
protected virtual async Task HandleNonAssetRequest(IOwinContext context, WorkContext workContext)
{
await InitializeShoppingCart(context, workContext);
if (workContext.CurrentStore.QuotesEnabled)
{
var quoteRequestBuilder = Container.Resolve <IQuoteRequestBuilder>();
await quoteRequestBuilder.GetOrCreateNewTransientQuoteRequestAsync(workContext.CurrentStore, workContext.CurrentCustomer, workContext.CurrentLanguage, workContext.CurrentCurrency);
workContext.CurrentQuoteRequest = quoteRequestBuilder.QuoteRequest;
}
var linkListService = Container.Resolve <IMenuLinkListService>();
var linkLists = await CacheManager.GetAsync("GetAllStoreLinkLists-" + workContext.CurrentStore.Id, "ApiRegion", async() => await linkListService.LoadAllStoreLinkListsAsync(workContext.CurrentStore.Id));
workContext.CurrentLinkLists = linkLists.GroupBy(x => x.Name).Select(x => x.FindWithLanguage(workContext.CurrentLanguage)).Where(x => x != null).ToList();
// load all static content
var staticContents = CacheManager.Get(string.Join(":", "AllStoreStaticContent", workContext.CurrentStore.Id), "ContentRegion", () =>
{
var staticContentService = Container.Resolve <IStaticContentService>();
var allContentItems = staticContentService.LoadStoreStaticContent(workContext.CurrentStore).ToList();
var blogs = allContentItems.OfType <Blog>().ToArray();
var blogArticlesGroup = allContentItems.OfType <BlogArticle>().GroupBy(x => x.BlogName, x => x).ToList();
foreach (var blog in blogs)
{
var blogArticles = blogArticlesGroup.FirstOrDefault(x => string.Equals(x.Key, blog.Name, StringComparison.OrdinalIgnoreCase));
if (blogArticles != null)
{
blog.Articles = new MutablePagedList <BlogArticle>(blogArticles);
}
}
return(new { Pages = allContentItems, Blogs = blogs });
});
workContext.Pages = new MutablePagedList <ContentItem>(staticContents.Pages.Where(x => x.Language.IsInvariant || x.Language == workContext.CurrentLanguage));
workContext.Blogs = new MutablePagedList <Blog>(staticContents.Blogs.Where(x => x.Language.IsInvariant || x.Language == workContext.CurrentLanguage));
// Initialize blogs search criteria
workContext.CurrentBlogSearchCritera = new BlogSearchCriteria(workContext.QueryString);
//Pricelists
var pricelistCacheKey = string.Join("-", "EvaluatePriceLists", workContext.CurrentStore.Id, workContext.CurrentCustomer.Id);
workContext.CurrentPricelists = await CacheManager.GetAsync(pricelistCacheKey, "ApiRegion", async() =>
{
var evalContext = workContext.ToPriceEvaluationContextDto();
var pricingModuleApi = Container.Resolve <IPricingModuleApiClient>();
var pricingResult = await pricingModuleApi.PricingModule.EvaluatePriceListsAsync(evalContext);
return(pricingResult.Select(p => p.ToPricelist(workContext.AllCurrencies, workContext.CurrentLanguage)).ToList());
});
// Vendors with their products
workContext.Vendors = new MutablePagedList <Vendor>((pageNumber, pageSize, sortInfos) =>
{
var catalogSearchService = Container.Resolve <ICatalogSearchService>();
var customerService = Container.Resolve <ICustomerService>();
var vendors = customerService.SearchVendors(null, pageNumber, pageSize, sortInfos);
foreach (var vendor in vendors)
{
vendor.Products = new MutablePagedList <Product>((pageNumber2, pageSize2, sortInfos2) =>
{
var criteria = new ProductSearchCriteria
{
VendorId = vendor.Id,
PageNumber = pageNumber2,
PageSize = pageSize2,
ResponseGroup = workContext.CurrentProductSearchCriteria.ResponseGroup & ~ItemResponseGroup.ItemWithVendor,
SortBy = SortInfo.ToString(sortInfos2),
};
var searchResult = catalogSearchService.SearchProducts(criteria);
return(searchResult.Products);
}, 1, ProductSearchCriteria.DefaultPageSize);
}
return(vendors);
}, 1, VendorSearchCriteria.DefaultPageSize);
}
/// <summary>
/// Return View with optional search criteria added.
/// </summary>
/// <param name="categoryId">Required: Category id to show products for.</param>
/// <param name="filterBrands">List of brands to show (comma separated).</param>
/// <param name="filterCategories">List of categories to show (comma separated).</param>
/// <returns>View of Products.</returns>
public async Task <ActionResult> Index(string categoryId = "", string[] filterBrands = null, string[] filterCategories = null)
{
EcommerceContext ecommerceContext = ServiceUtilities.GetEcommerceContext(this.HttpContext);
OrgUnitOperationsHandler orgUnitOperationsHandler = new OrgUnitOperationsHandler(ecommerceContext);
PagedResult <Category> categories = await orgUnitOperationsHandler.GetNavigationalHierarchyCategories(Utilities.DefaultQuerySettings);
IEnumerable <long> rawCategoryIds = categories.Select(c => c.RecordId);
// determine what category to load products for, if null, load all products
ObservableCollection <long> categoryIds;
if (string.IsNullOrEmpty(categoryId))
{
categoryIds = new ObservableCollection <long>(rawCategoryIds);
}
else
{
categoryIds = new ObservableCollection <long>();
categoryIds.Add(long.Parse(categoryId));
}
// Category Id to Name Mapping
Dictionary <long, string> mapping = new Dictionary <long, string>();
foreach (Category category in categories)
{
mapping.Add(category.RecordId, category.Name);
}
// Retrieving Products - make sure we include products from descendant categories too
ProductSearchCriteria searchCriteria = new ProductSearchCriteria
{
DataLevelValue = 4,
CategoryIds = categoryIds,
IncludeProductsFromDescendantCategories = true
};
// try and get product information
ProductOperationsHandler productOperationsHandler = new ProductOperationsHandler(ecommerceContext);
PagedResult <ProductCatalog> productCatalogs = await productOperationsHandler.GetProductCatalogs(Utilities.DefaultQuerySettings);
IEnumerable <long> activeCatalogIds = productCatalogs.Results.Select(pc => pc.RecordId);
PagedResult <Product> products = await productOperationsHandler.SearchProducts(searchCriteria, activeCatalogIds, Utilities.DefaultQuerySettings);
// Breadcrumb Navigation Links
Collection <CustomLink> breadcrumbNavLinks = new Collection <CustomLink>();
Category currentCategory = this.GetCategoryById(long.Parse(categoryId), categories);
while (!currentCategory.ParentCategory.Equals((long?)0))
{
breadcrumbNavLinks.Add(new CustomLink("/ProductGallery?categoryId=" + currentCategory.RecordId, currentCategory.Name));
currentCategory = this.GetCategoryById(currentCategory.ParentCategory, categories);
}
breadcrumbNavLinks.Add(new CustomLink("/", "Home"));
// Filter Mapping
Dictionary <string, string[]> filters = new Dictionary <string, string[]>();
filters.Add("brand", filterBrands);
filters.Add("categories", filterCategories);
IEnumerable <Product> productList = await ProductDetailsController.PopulateViewSpecificProductInfo(products.Results, ecommerceContext);
// create a new product gallery model for the view
ProductGalleryModel productGalleryModel = new ProductGalleryModel(long.Parse(categoryId), productList, breadcrumbNavLinks, mapping, filters);
return(this.View(ProductGalleryController.ProductGalleryViewName, productGalleryModel));
}
protected virtual IList <SortingField> GetSorting(ProductSearchCriteria criteria)
{
var result = new List <SortingField>();
//For sorting by relevance have to keep sortInfo clear
var needClearSortInfo = false;
var priorityFields = criteria.GetPriorityFields();
foreach (SortInfo sortInfo in criteria.SortInfos)
{
var sortingField = new SortingField();
if (sortInfo is GeoSortInfo geoSortInfo)
{
sortingField = new GeoDistanceSortingField
{
Location = geoSortInfo.GeoPoint
};
}
sortingField.FieldName = sortInfo.SortColumn.ToLowerInvariant();
sortingField.IsDescending = sortInfo.SortDirection == SortDirection.Descending;
switch (sortingField.FieldName)
{
case "relevance":
needClearSortInfo = true;
break;
case "price":
if (criteria.Pricelists != null)
{
result.AddRange(
criteria.Pricelists.Select(priceList => new SortingField($"price_{criteria.Currency}_{priceList}".ToLowerInvariant(), sortingField.IsDescending)));
}
break;
case "priority":
result.AddRange(priorityFields.Select(priorityField => new SortingField(priorityField, sortingField.IsDescending)));
break;
case "name":
case "title":
result.Add(new SortingField("name", sortingField.IsDescending));
break;
default:
result.Add(sortingField);
break;
}
}
if (!result.Any())
{
result.AddRange(priorityFields.Select(priorityField => new SortingField(priorityField, true)));
result.Add(new SortingField("__sort"));
}
if (needClearSortInfo)
{
result.Clear();
}
return(result);
}
protected virtual async Task HandleStorefrontRequest(IOwinContext context)
{
var workContext = Container.Resolve <WorkContext>();
// Initialize common properties
var qs = HttpUtility.ParseQueryString(context.Request.Uri.Query);
workContext.RequestUrl = context.Request.Uri;
workContext.QueryString = qs;
workContext.AllCountries = AllCountries;
workContext.AllStores = await CacheManager.GetAsync("GetAllStores", "ApiRegion", async() => await GetAllStoresAsync(), cacheNullValue : false);
if (workContext.AllStores != null && workContext.AllStores.Any())
{
// Initialize request specific properties
workContext.CurrentStore = GetStore(context, workContext.AllStores);
workContext.CurrentLanguage = GetLanguage(context, workContext.AllStores, workContext.CurrentStore);
if (!IsStaticAssetRequest(context.Request))
{
var commerceApi = Container.Resolve <ICoreModuleApiClient>();
workContext.AllCurrencies = await CacheManager.GetAsync("GetAllCurrencies-" + workContext.CurrentLanguage.CultureName, "ApiRegion", async() => { return((await commerceApi.Commerce.GetAllCurrenciesAsync()).Select(x => x.ToCurrency(workContext.CurrentLanguage)).ToArray()); });
//Sync store currencies with avail in system
foreach (var store in workContext.AllStores)
{
store.SyncCurrencies(workContext.AllCurrencies, workContext.CurrentLanguage);
store.CurrentSeoInfo = store.SeoInfos.FirstOrDefault(x => x.Language == workContext.CurrentLanguage);
}
//Set current currency
workContext.CurrentCurrency = GetCurrency(context, workContext.CurrentStore);
//Initialize catalog search criteria
workContext.CurrentProductSearchCriteria = new ProductSearchCriteria(workContext.CurrentLanguage, workContext.CurrentCurrency, qs);
//Initialize product response group. Exclude properties meta-information for performance reason (property values will be returned)
workContext.CurrentProductResponseGroup = EnumUtility.SafeParse(qs.Get("resp_group"), ItemResponseGroup.ItemLarge & ~ItemResponseGroup.ItemProperties);
workContext.PageNumber = qs.Get("page").ToNullableInt();
workContext.PageSize = qs.Get("count").ToNullableInt() ?? qs.Get("page_size").ToNullableInt();
var catalogSearchService = Container.Resolve <ICatalogSearchService>();
//This line make delay categories loading initialization (categories can be evaluated on view rendering time)
workContext.Categories = new MutablePagedList <Category>((pageNumber, pageSize, sortInfos) =>
{
var criteria = new CategorySearchCriteria(workContext.CurrentLanguage)
{
PageNumber = pageNumber,
PageSize = pageSize,
ResponseGroup = CategoryResponseGroup.Small
};
if (string.IsNullOrEmpty(criteria.SortBy) && !sortInfos.IsNullOrEmpty())
{
criteria.SortBy = SortInfo.ToString(sortInfos);
}
var result = catalogSearchService.SearchCategories(criteria);
foreach (var category in result)
{
category.Products = new MutablePagedList <Product>((pageNumber2, pageSize2, sortInfos2) =>
{
var productSearchCriteria = new ProductSearchCriteria(workContext.CurrentLanguage, workContext.CurrentCurrency)
{
PageNumber = pageNumber2,
PageSize = pageSize2,
Outline = category.Outline,
ResponseGroup = workContext.CurrentProductSearchCriteria.ResponseGroup
};
//criteria.CategoryId = category.Id;
if (string.IsNullOrEmpty(criteria.SortBy) && !sortInfos2.IsNullOrEmpty())
{
productSearchCriteria.SortBy = SortInfo.ToString(sortInfos2);
}
var searchResult = catalogSearchService.SearchProducts(productSearchCriteria);
//Because catalog search products returns also aggregations we can use it to populate workContext using C# closure
//now workContext.Aggregation will be contains preloaded aggregations for current category
workContext.Aggregations = new MutablePagedList <Aggregation>(searchResult.Aggregations);
return(searchResult.Products);
}, 1, ProductSearchCriteria.DefaultPageSize);
}
return(result);
}, 1, CategorySearchCriteria.DefaultPageSize);
//This line make delay products loading initialization (products can be evaluated on view rendering time)
workContext.Products = new MutablePagedList <Product>((pageNumber, pageSize, sortInfos) =>
{
var criteria = workContext.CurrentProductSearchCriteria.Clone();
criteria.PageNumber = pageNumber;
criteria.PageSize = pageSize;
if (string.IsNullOrEmpty(criteria.SortBy) && !sortInfos.IsNullOrEmpty())
{
criteria.SortBy = SortInfo.ToString(sortInfos);
}
var result = catalogSearchService.SearchProducts(criteria);
//Prevent double api request for get aggregations
//Because catalog search products returns also aggregations we can use it to populate workContext using C# closure
//now workContext.Aggregation will be contains preloaded aggregations for current search criteria
workContext.Aggregations = new MutablePagedList <Aggregation>(result.Aggregations);
return(result.Products);
}, 1, ProductSearchCriteria.DefaultPageSize);
//This line make delay aggregation loading initialization (aggregation can be evaluated on view rendering time)
workContext.Aggregations = new MutablePagedList <Aggregation>((pageNumber, pageSize, sortInfos) =>
{
var criteria = workContext.CurrentProductSearchCriteria.Clone();
criteria.PageNumber = pageNumber;
criteria.PageSize = pageSize;
if (string.IsNullOrEmpty(criteria.SortBy) && !sortInfos.IsNullOrEmpty())
{
criteria.SortBy = SortInfo.ToString(sortInfos);
}
//Force to load products and its also populate workContext.Aggregations by preloaded values
workContext.Products.Slice(pageNumber, pageSize, sortInfos);
return(workContext.Aggregations);
}, 1, ProductSearchCriteria.DefaultPageSize);
workContext.CurrentOrderSearchCriteria = new Model.Order.OrderSearchCriteria(qs);
workContext.CurrentQuoteSearchCriteria = new Model.Quote.QuoteSearchCriteria(qs);
//Get current customer
workContext.CurrentCustomer = await GetCustomerAsync(context);
//Validate that current customer has to store access
ValidateUserStoreLogin(context, workContext.CurrentCustomer, workContext.CurrentStore);
MaintainAnonymousCustomerCookie(context, workContext);
// Gets the collection of external login providers
var externalAuthTypes = context.Authentication.GetExternalAuthenticationTypes();
workContext.ExternalLoginProviders = externalAuthTypes.Select(at => new LoginProvider
{
AuthenticationType = at.AuthenticationType,
Caption = at.Caption,
Properties = at.Properties
}).ToList();
workContext.ApplicationSettings = GetApplicationSettings();
//Do not load shopping cart and other for resource requests
if (!IsAssetRequest(context.Request))
{
await HandleNonAssetRequest(context, workContext);
}
}
}
}
public List <ProductInventoryListViewModel> GetInventoryBySearch(ProductSearchCriteria searchCriteriaObject)
{
return(_productRepository.GetInventoryBySearch(searchCriteriaObject));
}
public List <Product> GetProductsBySearch(ProductSearchCriteria searchCriteriaObject)
{
return(_productRepository.GetProductsBySearch(searchCriteriaObject));
}
private void RouteProductCall(Operation op, ProductEntity entry)
{
const string ReviewType = "FullReview";
if (op == Operation.Publish) // publish
{
var product = GetCatalogProduct(entry, out bool isNew);
product.IsActive = true;
if (entry.Content != null)
{
var list = new List <EditorialReview>();
foreach (var lang in entry.Content.Keys)
{
var review = new EditorialReview()
{
Content = entry.Content[lang],
ReviewType = ReviewType,
LanguageCode = lang
};
list.Add(review);
}
// add new reviews or update existing ones
if (product.Reviews == null)
{
product.Reviews = list.ToArray();
}
else
{
foreach (var review in list)
{
var existingReview = product.Reviews.Where(x => x.ReviewType == ReviewType && x.LanguageCode == review.LanguageCode).SingleOrDefault();
if (existingReview == null)
{
product.Reviews.Add(review);
}
else
{
existingReview.Content = review.Content;
}
}
}
}
// now add all the properties
if (entry.Properties != null)
{
var propValuesList = new List <PropertyValue>();
foreach (var key in entry.Properties.Keys)
{
var prop = entry.Properties[key];
foreach (var lang in prop.Keys)
{
var proValue = new PropertyValue()
{
LanguageCode = lang,
PropertyName = key,
Value = prop[lang]
};
propValuesList.Add(proValue);
}
}
propValuesList.Add(new PropertyValue()
{
PropertyName = "contentfulid", Value = entry.Id
});
// add new properties or update existing ones
if (product.PropertyValues == null)
{
product.PropertyValues = propValuesList.ToArray();
}
else
{
foreach (var propertyValue in propValuesList)
{
var existingPropertyValue = product.PropertyValues.Where(x => x.PropertyName == propertyValue.PropertyName && x.LanguageCode == propertyValue.LanguageCode).SingleOrDefault();
if (existingPropertyValue == null)
{
product.PropertyValues.Add(propertyValue);
}
else
{
existingPropertyValue.Value = propertyValue.Value;
}
}
}
}
if (isNew)
{
_itemService.Create(product);
}
else
{
_itemService.Update(new[] { product });
}
}
else if (op == Operation.Unpublish || op == Operation.Delete) // unpublish
{
var criteria = new ProductSearchCriteria();
criteria.Terms = new[] { string.Format("contentfulid:{0}", entry.Id) };
var result = _productSearchService.SearchAsync(criteria).Result;
if (result.TotalCount > 0)
{
var product = _itemService.GetById(result.Items[0].Id, ItemResponseGroup.ItemLarge); // reload complete product now
product.IsActive = false;
_itemService.Update(new[] { product });
}
}
}
public IEnumerable <Product> Get(ProductSearchCriteria searchCriteria)
{
throw new NotImplementedException();
}
public Task <PagedResult <ProductRefiner> > GetRefiners(ProductSearchCriteria productSearchCriteria, QueryResultSettings queryResultSettings)
{
return(Task.Run(() => Runtime.Client.ProductManager.Create(CommerceRuntimeManager.Runtime).GetRefiners(productSearchCriteria)));
}
/// <summary>
/// Search products by given criteria
/// </summary>
/// <param name="criteria"></param>
/// <returns></returns>
public virtual CatalogSearchResult SearchProducts(ProductSearchCriteria criteria)
{
return(SearchProductsAsync(criteria).GetAwaiter().GetResult());
}
public Task <PagedResult <Product> > Search(ProductSearchCriteria productSearchCriteria, QueryResultSettings queryResultSettings)
{
return(Task.Run(() => Runtime.Client.ProductManager.Create(CommerceRuntimeManager.Runtime).SearchProducts(productSearchCriteria, queryResultSettings).Results.ToCRTPagedResult()));
}
public IEnumerable <Product> Get([FromQuery] ProductSearchCriteria searchCriteria)
{
var products = productService.Get(searchCriteria);
return(products);
}
/// <summary>
/// Executes the workflow to retrieve the prices and calculated discount amount for the given product identifiers.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>The response.</returns>
protected override GetIndependentProductPriceDiscountResponse Process(GetIndependentProductPriceDiscountRequest request)
{
ThrowIf.Null(request, "request");
ProductSearchCriteria productSearchCriteria = new ProductSearchCriteria(
request.Context.ChannelId.GetValueOrDefault(),
request.Context.CatalogId.GetValueOrDefault())
{
DataLevel = CommerceEntityDataLevel.Standard,
Ids = request.ProductIds.ToList()
};
ProductSearchResultContainer productSearchResult = request.RequestContext.Runtime.Execute <ProductSearchServiceResponse>(
new ProductSearchServiceRequest(productSearchCriteria, request.QueryResultSettings), request.RequestContext).ProductSearchResult;
List <ProductPrice> productPrices = new List <ProductPrice>(request.ProductIds.Count());
// Create sales line for every product id there is in the request.
List <SalesLine> salesLines = new List <SalesLine>(request.ProductIds.Count());
foreach (var product in productSearchResult.Results)
{
if (product.IsMasterProduct)
{
foreach (var variant in product.GetVariants())
{
if (request.ProductIds.Contains(variant.DistinctProductVariantId))
{
salesLines.Add(new SalesLine
{
ItemId = product.ItemId,
Variant = variant,
InventoryDimensionId = variant.InventoryDimensionId,
SalesOrderUnitOfMeasure = product.Rules.DefaultUnitOfMeasure,
LineId = System.Guid.NewGuid().ToString("N"),
Quantity = 1,
ProductId = variant.DistinctProductVariantId,
CatalogId = request.Context.CatalogId.GetValueOrDefault()
});
}
}
}
else
{
salesLines.Add(new SalesLine
{
ItemId = product.ItemId,
SalesOrderUnitOfMeasure = product.Rules.DefaultUnitOfMeasure,
LineId = System.Guid.NewGuid().ToString("N"),
Quantity = 1,
ProductId = product.RecordId,
CatalogId = request.Context.CatalogId.GetValueOrDefault()
});
}
}
// Set the catalog ids on the sales lines.
if (request.Context.CatalogId != null)
{
if (request.Context.CatalogId.Value > 0)
{
// If a specific catalogId is set on the context, add it to the catalogIds on the sales lines.
foreach (var sl in salesLines)
{
sl.CatalogIds.Add(request.Context.CatalogId.Value);
}
}
else
{
GetProductCatalogAssociationsDataRequest productCatalogAssociationRequest = new GetProductCatalogAssociationsDataRequest(salesLines.Select(p => p.ProductId))
{
QueryResultSettings = QueryResultSettings.AllRecords
};
ReadOnlyCollection <ProductCatalogAssociation> productCatalogs = request.RequestContext.Runtime.Execute <GetProductCatalogAssociationsDataResponse>(
productCatalogAssociationRequest,
request.RequestContext).CatalogAssociations;
// If catalogId is 0, add all independent catalogs to the catalogIds on the sales lines.
foreach (var sl in salesLines)
{
sl.CatalogIds.UnionWith(productCatalogs.Where(pc => pc.ProductRecordId == sl.ProductId).Select(pc => pc.CatalogRecordId));
}
}
}
Collection <SalesAffiliationLoyaltyTier> affiliations = null;
if (request.AffiliationLoyaltyTiers != null)
{
affiliations = new Collection <SalesAffiliationLoyaltyTier>((from alt in request.AffiliationLoyaltyTiers
select new SalesAffiliationLoyaltyTier
{
AffiliationId = alt.AffiliationId,
AffiliationType = alt.AffiliationType,
LoyaltyTierId = alt.LoyaltyTierId,
ReasonCodeLines = alt.ReasonCodeLines,
CustomerId = alt.CustomerId,
ChannelId = request.Context.ChannelId.GetValueOrDefault()
}).ToList());
}
SalesTransaction transaction = new SalesTransaction
{
SalesLines = new Collection <SalesLine>(salesLines),
CustomerId = request.CustomerAccountNumber,
AffiliationLoyaltyTierLines = affiliations
};
// Calculate prices and discounts for sales lines
GetIndependentPriceDiscountServiceRequest itemPriceDiscountServiceRequest = new GetIndependentPriceDiscountServiceRequest(transaction);
GetPriceServiceResponse itemPriceServiceResponse = this.Context.Execute <GetPriceServiceResponse>(itemPriceDiscountServiceRequest);
Dictionary <long, SalesLine> salesLineDictionary = itemPriceServiceResponse.Transaction.SalesLines.ToDictionary(sl => sl.ProductId);
foreach (long productId in request.ProductIds)
{
SalesLine salesLine;
if (!salesLineDictionary.TryGetValue(productId, out salesLine))
{
salesLine = new SalesLine();
}
ProductPrice productPrice = new ProductPrice
{
UnitOfMeasure = salesLine.SalesOrderUnitOfMeasure,
ItemId = salesLine.ItemId,
InventoryDimensionId = salesLine.InventoryDimensionId,
BasePrice = salesLine.BasePrice,
TradeAgreementPrice = salesLine.AgreementPrice,
AdjustedPrice = salesLine.AdjustedPrice,
DiscountAmount = salesLine.DiscountAmount,
ProductId = productId,
ChannelId = request.Context.ChannelId.GetValueOrDefault(),
CatalogId = request.Context.CatalogId.GetValueOrDefault()
};
productPrices.Add(productPrice);
}
return(new GetIndependentProductPriceDiscountResponse(productPrices.AsPagedResult()));
}
protected virtual IQueryable <ItemEntity> BuildQuery(ICatalogRepository repository, ProductSearchCriteria criteria)
{
var query = repository.Items;
if (!string.IsNullOrEmpty(criteria.Keyword))
{
query = query.Where(x => x.Name.Contains(criteria.Keyword));
}
if (!criteria.CategoryIds.IsNullOrEmpty())
{
var searchCategoryIds = criteria.CategoryIds;
if (criteria.SearchInChildren)
{
searchCategoryIds = searchCategoryIds.Concat(repository.GetAllChildrenCategoriesIdsAsync(searchCategoryIds).GetAwaiter().GetResult()).ToArray();
}
query = query.Where(x => searchCategoryIds.Contains(x.CategoryId) || x.CategoryLinks.Any(link => searchCategoryIds.Contains(link.CategoryId)));
}
if (!criteria.CatalogIds.IsNullOrEmpty())
{
query = query.Where(x => criteria.CatalogIds.Contains(x.CatalogId));
}
if (!criteria.Skus.IsNullOrEmpty())
{
query = query.Where(x => criteria.Skus.Contains(x.Code));
}
if (!string.IsNullOrEmpty(criteria.MainProductId))
{
query = query.Where(x => x.ParentId == criteria.MainProductId);
}
else if (!criteria.SearchInVariations)
{
query = query.Where(x => x.ParentId == null);
}
return(query);
}
/// <summary>
/// Get the Details for a particular product.
/// </summary>
/// <param name="productId">The product id you need the details for.</param>
/// <returns>The View for that product.</returns>
public async Task <ActionResult> Index(string productId = "")
{
EcommerceContext ecommerceContext = ServiceUtilities.GetEcommerceContext(this.HttpContext);
OrgUnitOperationsHandler orgUnitOperationsHandler = new OrgUnitOperationsHandler(ecommerceContext);
PagedResult <Category> categories = await orgUnitOperationsHandler.GetNavigationalHierarchyCategories(Utilities.DefaultQuerySettings);
IEnumerable <long> rawCategoryIds = categories.Select(c => c.RecordId);
ObservableCollection <long> productIds = null;
Product prod = null;
Collection <CustomLink> breadcrumbNavLinks = new Collection <CustomLink>();
long productIdentifier;
if (string.IsNullOrEmpty(productId) || !long.TryParse(productId, out productIdentifier))
{
RetailLogger.Log.OnlineStoreInvalidProductIdProvided(productId);
return(this.RedirectToAction(HomeController.DefaultActionName, HomeController.ControllerName));
}
else
{
// add productId to an ObservableCollection
productIds = new ObservableCollection <long>();
productIds.Add(productIdentifier);
ProductSearchCriteria searchCriteria = new ProductSearchCriteria
{
DataLevelValue = 4,
Ids = productIds
};
// try and get product information
ProductOperationsHandler productOperationsHandler = new ProductOperationsHandler(ecommerceContext);
PagedResult <ProductCatalog> productCatalogs = await productOperationsHandler.GetProductCatalogs(Utilities.DefaultQuerySettings);
IEnumerable <long> activeCatalogIds = productCatalogs.Results.Select(pc => pc.RecordId);
PagedResult <Product> products = await productOperationsHandler.SearchProducts(searchCriteria, activeCatalogIds, Utilities.DefaultQuerySettings);
if (!products.Results.Any())
{
var message = string.Format("ProductIds: {0}.", string.Join(",", productIds));
RetailLogger.Log.OnlineStoreNoProductsFound(message);
return(this.RedirectToAction(HomeController.DefaultActionName, HomeController.ControllerName));
}
prod = products.Results.First <Product>();
// Breadcrumb Navigation Links
// add current item
breadcrumbNavLinks.Add(new CustomLink("/ProductDetails?productId=" + prod.RecordId, prod.ProductName));
Category currentCategory = this.GetCategoryById(prod.CategoryIds.First(), categories);
while (currentCategory.ParentCategory != 0)
{
breadcrumbNavLinks.Add(new CustomLink("/ProductGallery?categoryId=" + currentCategory.RecordId, currentCategory.Name));
currentCategory = this.GetCategoryById(currentCategory.ParentCategory, categories);
}
breadcrumbNavLinks.Add(new CustomLink("/", "Home"));
}
prod = (await ProductDetailsController.PopulateViewSpecificProductInfo(new Product[] { prod }, ecommerceContext)).FirstOrDefault();
return(this.View(ProductDetailsController.ProductDetailsViewName, new ProductDetailsModel(prod, breadcrumbNavLinks)));
}
public virtual Aggregation[] ConvertAggregations(IList <AggregationResponse> aggregationResponses, ProductSearchCriteria criteria)
{
var result = new List <Aggregation>();
var browseFilters = _browseFilterService.GetBrowseFilters(criteria);
if (browseFilters != null && aggregationResponses?.Any() == true)
{
foreach (var filter in browseFilters)
{
Aggregation aggregation = null;
var attributeFilter = filter as AttributeFilter;
var rangeFilter = filter as RangeFilter;
var priceRangeFilter = filter as PriceRangeFilter;
if (attributeFilter != null)
{
aggregation = GetAttributeAggregation(attributeFilter, aggregationResponses);
}
else if (rangeFilter != null)
{
aggregation = GetRangeAggregation(rangeFilter, aggregationResponses);
}
else if (priceRangeFilter != null)
{
aggregation = GetPriceRangeAggregation(priceRangeFilter, aggregationResponses);
}
if (aggregation?.Items?.Any() == true)
{
result.Add(aggregation);
}
}
}
// Add localized labels for names and values
if (result.Any())
{
AddLabels(result, criteria.CatalogId);
}
return(result.ToArray());
}
protected virtual async Task <catalogDto.ProductIndexedSearchResult> SearchProductsAsync(ProductSearchCriteria criteria, WorkContext workContext)
{
var cacheKey = CacheKey.With(GetType(), nameof(SearchProductsAsync), criteria.GetCacheKey(), workContext.CurrentStore.Id, workContext.CurrentLanguage.CultureName, workContext.CurrentCurrency.Code);
return(await _memoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(CatalogCacheRegion.CreateChangeToken());
cacheEntry.AddExpirationToken(_apiChangesWatcher.CreateChangeToken());
criteria = criteria.Clone() as ProductSearchCriteria;
var searchCriteria = criteria.ToProductSearchCriteriaDto(workContext);
return await _searchApi.SearchProductsAsync(searchCriteria);
}));
}
/// <summary>
/// Search products by given criteria
/// </summary>
/// <param name="criteria"></param>
/// <returns></returns>
public virtual CatalogSearchResult SearchProducts(ProductSearchCriteria criteria)
{
var workContext = _workContextAccessor.WorkContext;
return(Task.Factory.StartNew(() => InnerSearchProductsAsync(criteria, workContext), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
/// <summary>
/// Processes the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// Available quantities of specified listings at the requested warehouse.
/// </returns>
protected override GetListingAvailableQuantitiesResponse Process(GetListingAvailableQuantitiesRequest request)
{
ThrowIf.Null(request, "request");
ThrowIf.NullOrEmpty(request.ProductIds, "No Ids have been provided");
QueryResultSettings settings = QueryResultSettings.AllRecords;
var productIds = request.ProductIds.Distinct().ToList();
ProductSearchCriteria queryCriteria = new ProductSearchCriteria(this.Context.GetPrincipal().ChannelId)
{
Ids = productIds,
DataLevel = CommerceEntityDataLevel.Identity,
};
var productSearchResult = request.RequestContext.Runtime.Execute <ProductSearchServiceResponse>(
new ProductSearchServiceRequest(queryCriteria, settings), request.RequestContext).ProductSearchResult;
if (productSearchResult.Results.IsNullOrEmpty())
{
string nonResolvedProductIdsInfo = string.Join(" ", productIds);
//// This is a valid situtation for cross channel scenarios, wish lists for example.
NetTracer.Warning("None of the specified product ids were found on the current channel {0}. ProductIds = {1}", this.Context.GetPrincipal().ChannelId, nonResolvedProductIdsInfo);
return(new GetListingAvailableQuantitiesResponse());
}
var productMap = productSearchResult.Results.ToDictionary(p => p.RecordId, p => p);
var items = this.GetItemAndInventDimId(productIds, productSearchResult, productMap);
settings = new QueryResultSettings(new PagingInfo(items.Count(), 0));
var itemAvailabilities = new HashSet <ItemAvailability>();
var itemUnits = new HashSet <ItemUnit>();
if (request.ChannelId == 0)
{
var itemVariantInventoryDimensions = new HashSet <ItemVariantInventoryDimension>();
foreach (var item in items)
{
itemVariantInventoryDimensions.Add(new ItemVariantInventoryDimension(item.Item1, item.Item2));
}
var itemAvailableQuantitiesRequest = new GetItemAvailableQuantitiesByItemsServiceRequest(settings, itemVariantInventoryDimensions, string.Empty);
var itemAvailableQuantitiesResponse = this.Context.Execute <GetItemAvailableQuantitiesByItemsServiceResponse>(itemAvailableQuantitiesRequest);
foreach (var quantity in itemAvailableQuantitiesResponse.ItemAvailableQuantities.Results)
{
if (quantity != null)
{
var productAvailableQuantity = new ItemAvailability
{
ItemId = quantity.ItemId,
VariantInventoryDimensionId = quantity.VariantInventoryDimensionId,
AvailableQuantity = quantity.AvailableQuantity,
UnitOfMeasure = quantity.UnitOfMeasure
};
itemAvailabilities.Add(productAvailableQuantity);
var itemUnit = new ItemUnit
{
ItemId = quantity.ItemId,
VariantInventoryDimensionId = quantity.VariantInventoryDimensionId,
UnitOfMeasure = items.Where(i => i.Item1.Equals(quantity.ItemId) && i.Item2.Equals(quantity.VariantInventoryDimensionId)).SingleOrDefault().Item3
};
itemUnits.Add(itemUnit);
}
}
}
else
{
var itemWarehouses = new HashSet <ItemWarehouse>();
foreach (var item in items)
{
var itemWarehouse = new ItemWarehouse()
{
ItemId = item.Item1,
VariantInventoryDimensionId = item.Item2,
InventoryLocationId = this.Context.GetChannelConfiguration().InventLocation
};
itemWarehouses.Add(itemWarehouse);
}
var warehouseRequest = new GetItemAvailabilitiesByItemWarehousesServiceRequest(settings, itemWarehouses);
var warehouseResponse = this.Context.Execute <GetItemAvailabilitiesByItemWarehousesServiceResponse>(warehouseRequest);
foreach (var quantity in warehouseResponse.ItemAvailabilities.Results)
{
if (quantity != null)
{
itemAvailabilities.Add(quantity);
var itemUnit = new ItemUnit
{
ItemId = quantity.ItemId,
VariantInventoryDimensionId = quantity.VariantInventoryDimensionId,
UnitOfMeasure = items.Where(i => i.Item1.Equals(quantity.ItemId) && i.Item2.Equals(quantity.VariantInventoryDimensionId)).SingleOrDefault().Item3
};
itemUnits.Add(itemUnit);
}
}
}
var itemAvailabilitiesList = ChannelAvailabilityHelper.ConvertUnitOfMeasure(this.Context, itemAvailabilities.ToList(), itemUnits.ToList());
var processedAvailabilities = this.ProcessItemAvailabilities(itemAvailabilitiesList, productIds, productSearchResult, productMap);
return(new GetListingAvailableQuantitiesResponse(processedAvailabilities.AsPagedResult()));
}
protected virtual IFilter ConvertBrowseFilter(IBrowseFilter filter, IList <string> valueIds, ProductSearchCriteria criteria)
{
IFilter result = null;
if (filter != null && valueIds != null)
{
var attributeFilter = filter as AttributeFilter;
var rangeFilter = filter as BrowseFilters.RangeFilter;
var priceRangeFilter = filter as PriceRangeFilter;
if (attributeFilter != null)
{
result = ConvertAttributeFilter(attributeFilter, valueIds);
}
else if (rangeFilter != null)
{
result = ConvertRangeFilter(rangeFilter, valueIds);
}
else if (priceRangeFilter != null)
{
result = ConvertPriceRangeFilter(priceRangeFilter, valueIds, criteria);
}
}
return(result);
}
public IActionResult Get([FromQuery] ProductSearchCriteria criteria)
{
var products = productsService.Get(criteria);
return(Ok(products));
}
protected virtual IList <AggregationRequest> GetPriceRangeFilterAggregationRequests(PriceRangeFilter priceRangeFilter, ProductSearchCriteria criteria, IList <IFilter> existingFilters)
{
var result = priceRangeFilter.Values.Select(v => GetPriceRangeFilterValueAggregationRequest(priceRangeFilter, v, existingFilters, criteria.Pricelists)).ToList();
return(result);
}
public Task <IEnumerable <Product> > GetAsync(ProductSearchCriteria criteria)
{
// return Task.FromResult(Get(criteria));
return(Task.Run(() => Get(criteria)));
}
