private SearchInfo GetSearchInfo(string searchKeyword, int?pageNumber, string facetValues, string sortField, int?pageSize, CommerceConstants.SortDirection?sortDirection)
{
if (this.CurrentSiteContext.Items[CurrentSearchInfoKeyName] != null)
{
return((SearchInfo)this.CurrentSiteContext.Items[CurrentSearchInfoKeyName]);
}
var searchManager = CommerceTypeLoader.CreateInstance <ICommerceSearchManager>();
var searchInfo = new SearchInfo
{
SearchKeyword = searchKeyword ?? string.Empty,
RequiredFacets = searchManager.GetFacetFieldsForItem(this.Item),
SortFields = searchManager.GetSortFieldsForItem(this.Item),
Catalog = StorefrontManager.CurrentStorefront.DefaultCatalog,
ItemsPerPage = pageSize ?? searchManager.GetItemsPerPageForItem(this.Item)
};
if (searchInfo.ItemsPerPage == 0)
{
searchInfo.ItemsPerPage = StorefrontConstants.Settings.DefaultItemsPerPage;
}
var productSearchOptions = new CommerceSearchOptions(searchInfo.ItemsPerPage, pageNumber.GetValueOrDefault(0));
this.UpdateOptionsWithFacets(searchInfo.RequiredFacets, facetValues, productSearchOptions);
this.UpdateOptionsWithSorting(sortField, sortDirection, productSearchOptions);
searchInfo.SearchOptions = productSearchOptions;
this.CurrentSiteContext.Items[CurrentSearchInfoKeyName] = searchInfo;
return(searchInfo);
}
/// <summary>
/// Adds the line item to cart.
/// </summary>
/// <param name="storefront">The storefront.</param>
/// <param name="visitorContext">The visitor context.</param>
/// <param name="inputModelList">The input model.</param>
/// <returns>
/// The manager response where the result is retuned indicating the success or failure of the operation.
/// </returns>
public virtual ManagerResponse <CartResult, bool> AddLineItemsToCart([NotNull] CommerceStorefront storefront, [NotNull] VisitorContext visitorContext, IEnumerable <AddCartLineInputModel> inputModelList)
{
Assert.ArgumentNotNull(inputModelList, "inputModelList");
var cartResult = this.LoadCartByName(storefront.ShopName, storefront.DefaultCartName, visitorContext.UserId, false);
if (!cartResult.Success || cartResult.Cart == null)
{
var message = StorefrontManager.GetSystemMessage(StorefrontConstants.SystemMessages.CartNotFoundError);
cartResult.SystemMessages.Add(new SystemMessage {
Message = message
});
return(new ManagerResponse <CartResult, bool>(cartResult, cartResult.Success));
}
var lines = new List <CartLine>();
foreach (var inputModel in inputModelList)
{
Assert.ArgumentNotNullOrEmpty(inputModel.ProductId, "inputModel.ProductId");
Assert.ArgumentNotNullOrEmpty(inputModel.CatalogName, "inputModel.CatalogName");
Assert.ArgumentNotNull(inputModel.Quantity, "inputModel.Quantity");
var quantity = (uint)inputModel.Quantity;
//// Special handling for a Gift Card
if (inputModel.ProductId.Equals(storefront.GiftCardProductId, StringComparison.OrdinalIgnoreCase))
{
inputModel.VariantId = inputModel.GiftCardAmount.Value.ToString("000", CultureInfo.InvariantCulture);
}
var cartLine = new CommerceCartLine(inputModel.CatalogName, inputModel.ProductId, inputModel.VariantId == "-1" ? null : inputModel.VariantId, quantity);
cartLine.Properties["ProductUrl"] = inputModel.ProductUrl;
cartLine.Properties["ImageUrl"] = inputModel.ImageUrl;
//// UpdateStockInformation(storefront, visitorContext, cartLine, inputModel.CatalogName);
lines.Add(cartLine);
}
var cartCache = CommerceTypeLoader.CreateInstance <CartCacheHelper>();
cartCache.InvalidateCartCache(visitorContext.GetCustomerId());
var cart = cartResult.Cart as CommerceCart;
var addLinesRequest = new AddCartLinesRequest(cart, lines);
addLinesRequest.RefreshCart(true);
var addLinesResult = this.CartServiceProvider.AddCartLines(addLinesRequest);
if (addLinesResult.Success && addLinesResult.Cart != null)
{
cartCache.AddCartToCache(addLinesResult.Cart as CommerceCart);
}
this.AddBasketErrorsToResult(addLinesResult.Cart as CommerceCart, addLinesResult);
Helpers.LogSystemMessages(addLinesResult.SystemMessages, addLinesResult);
return(new ManagerResponse <CartResult, bool>(addLinesResult, addLinesResult.Success));
}
/// <summary>
/// Gets the profile repository.
/// </summary>
/// <returns>An instance of the profile respository.</returns>
protected virtual ICommerceProfileRepository GetProfileRepository()
{
if (this._profileRepository == null)
{
this._profileRepository = CommerceTypeLoader.CreateInstance <ICommerceProfileRepository>();
}
return(this._profileRepository);
}
public SearchSettingsProvider(ICatalogContext catalogContext)
{
Assert.ArgumentNotNull(catalogContext, nameof(catalogContext));
this.catalogContext = catalogContext;
this.commerceSearchManager = CommerceTypeLoader.CreateInstance <ICommerceSearchManager>();
Assert.ArgumentNotNull(this.commerceSearchManager, nameof(this.commerceSearchManager));
}
/// <summary>
/// Initializes the specified order headers.
/// </summary>
/// <param name="orderHeaders">The order headers.</param>
public virtual void Initialize(IEnumerable <OrderHeader> orderHeaders)
{
Assert.ArgumentNotNull(orderHeaders, "orderHeaders");
foreach (var orderHeader in orderHeaders)
{
var headerItem = CommerceTypeLoader.CreateInstance <OrderHeaderItemBaseJsonResult>(orderHeader);
this._orders.Add(headerItem);
}
}
/// <summary>
/// Submits the visitor order.
/// </summary>
/// <param name="storefront">The storefront.</param>
/// <param name="visitorContext">The visitor context.</param>
/// <param name="inputModel">The input model.</param>
/// <returns>
/// The manager response where the new CommerceOrder is returned in the Result.
/// </returns>
public ManagerResponse <SubmitVisitorOrderResult, CommerceOrder> SubmitVisitorOrder([NotNull] CommerceStorefront storefront, [NotNull] VisitorContext visitorContext, [NotNull] SubmitOrderInputModel inputModel)
{
Assert.ArgumentNotNull(storefront, "storefront");
Assert.ArgumentNotNull(visitorContext, "visitorContext");
Assert.ArgumentNotNull(inputModel, "inputModel");
SubmitVisitorOrderResult errorResult = new SubmitVisitorOrderResult {
Success = false
};
var response = this.CartManager.GetCurrentCart(storefront, visitorContext, true);
if (!response.ServiceProviderResult.Success || response.Result == null)
{
response.ServiceProviderResult.SystemMessages.ToList().ForEach(m => errorResult.SystemMessages.Add(m));
return(new ManagerResponse <SubmitVisitorOrderResult, CommerceOrder>(errorResult, null));
}
var cart = (CommerceCart)response.ServiceProviderResult.Cart;
if (cart.Lines.Count == 0)
{
errorResult.SystemMessages.Add(new SystemMessage {
Message = StorefrontManager.GetSystemMessage(StorefrontConstants.SystemMessages.SubmitOrderHasEmptyCart)
});
return(new ManagerResponse <SubmitVisitorOrderResult, CommerceOrder>(errorResult, null));
}
var cartChanges = new CommerceCart();
cartChanges.Properties["Email"] = inputModel.UserEmail;
var updateCartResult = this.CartManager.UpdateCart(storefront, visitorContext, cart, cartChanges);
if (!updateCartResult.ServiceProviderResult.Success)
{
response.ServiceProviderResult.SystemMessages.ToList().ForEach(m => errorResult.SystemMessages.Add(m));
return(new ManagerResponse <SubmitVisitorOrderResult, CommerceOrder>(errorResult, null));
}
var request = new SubmitVisitorOrderRequest(cart);
request.RefreshCart(true);
errorResult = this.OrderServiceProvider.SubmitVisitorOrder(request);
if (errorResult.Success && errorResult.Order != null && errorResult.CartWithErrors == null)
{
var cartCache = CommerceTypeLoader.CreateInstance <CartCacheHelper>();
cartCache.InvalidateCartCache(visitorContext.GetCustomerId());
}
Helpers.LogSystemMessages(errorResult.SystemMessages, errorResult);
return(new ManagerResponse <SubmitVisitorOrderResult, CommerceOrder>(errorResult, errorResult.Order as CommerceOrder));
}
/// <summary>
/// Gets the product id from the incomming request
/// </summary>
/// <returns>The product id if found</returns>
public virtual CatalogRouteData GetCatalogItemFromIncomingRequest()
{
var siteContext = CommerceTypeLoader.CreateInstance <ISiteContext>();
var routeData = RouteTable.Routes.GetRouteData(new HttpContextWrapper(siteContext.CurrentContext));
if (routeData != null)
{
var data = this.GetRouteDataValue(routeData);
return(data);
}
return(null);
}
/// <summary>
/// Gets the tags.
/// </summary>
/// <returns>The Html metadata tags if necessary.</returns>
public static HtmlString GetTags()
{
var siteContext = CommerceTypeLoader.CreateInstance <ISiteContext>();
if (siteContext.IsCategory)
{
return(new HtmlString(GetCategoryTags(siteContext.CurrentCatalogItem)));
}
else if (siteContext.IsProduct)
{
return(new HtmlString(GetProductTags(siteContext.CurrentCatalogItem)));
}
return(new HtmlString(string.Empty));
}
/// <summary>
/// Gets the child variants read only.
/// </summary>
/// <param name="itemId">The item identifier.</param>
/// <param name="language">The language.</param>
/// <returns>Product variant collection.</returns>
private Category GetCategoryReadOnly(ID itemId, string language)
{
Category category = null;
var catalogRepository = CommerceTypeLoader.CreateInstance <ICatalogRepository>();
var externalInfo = catalogRepository.GetExternalIdInformation(itemId.Guid);
if (externalInfo != null && externalInfo.CommerceItemType == CommerceItemType.Category)
{
var culture = CommerceUtility.ConvertLanguageToCulture(language);
category = catalogRepository.GetCategoryReadOnly(externalInfo.CatalogName, externalInfo.CategoryName, culture) as Category;
}
return(category);
}
/// <summary>
/// Sets the shipping methods.
/// </summary>
/// <param name="storefront">The storefront.</param>
/// <param name="visitorContext">The visitor context.</param>
/// <param name="inputModel">The input model.</param>
/// <returns>
/// The manager response where the modified CommerceCart is returned in the Result.
/// </returns>
public virtual ManagerResponse <AddShippingInfoResult, CommerceCart> SetShippingMethods([NotNull] CommerceStorefront storefront, [NotNull] VisitorContext visitorContext, [NotNull] SetShippingMethodsInputModel inputModel)
{
Assert.ArgumentNotNull(storefront, "storefront");
Assert.ArgumentNotNull(visitorContext, "visitorContext");
Assert.ArgumentNotNull(inputModel, "inputModel");
var result = new AddShippingInfoResult {
Success = false
};
var response = this.GetCurrentCart(storefront, visitorContext, true);
if (!response.ServiceProviderResult.Success || response.Result == null)
{
return(new ManagerResponse <AddShippingInfoResult, CommerceCart>(result, response.Result));
}
var cart = (CommerceCart)response.ServiceProviderResult.Cart;
if (inputModel.ShippingAddresses != null && inputModel.ShippingAddresses.Any())
{
var cartParties = cart.Parties.ToList();
cartParties.AddRange(inputModel.ShippingAddresses.ToParties());
cart.Parties = cartParties.AsReadOnly();
}
var internalShippingList = inputModel.ShippingMethods.ToShippingInfoList();
var orderPreferenceType = InputModelExtension.GetShippingOptionType(inputModel.OrderShippingPreferenceType);
if (orderPreferenceType != ShippingOptionType.DeliverItemsIndividually)
{
foreach (var shipping in internalShippingList)
{
shipping.LineIDs = (from CommerceCartLine lineItem in cart.Lines select lineItem.ExternalCartLineId).ToList().AsReadOnly();
}
}
var cartCache = CommerceTypeLoader.CreateInstance <CartCacheHelper>();
cartCache.InvalidateCartCache(visitorContext.GetCustomerId());
result = this.AddShippingInfoToCart(cart, orderPreferenceType, internalShippingList);
if (result.Success && result.Cart != null)
{
cartCache.AddCartToCache(result.Cart as CommerceCart);
}
return(new ManagerResponse <AddShippingInfoResult, CommerceCart>(result, result.Cart as CommerceCart));
}
private IQueryable <CommerceSellableItemSearchResultItem> GetBaseQueryable(string catalogName, string searchItemType)
{
Assert.ArgumentNotNullOrEmpty(catalogName, nameof(catalogName));
Assert.ArgumentNotNullOrEmpty(searchItemType, nameof(searchItemType));
var commerceSearchManager = CommerceTypeLoader.CreateInstance <ICommerceSearchManager>();
using (var searchContext = commerceSearchManager.GetIndex(catalogName).CreateSearchContext())
{
var searchResultItems = searchContext.GetQueryable <CommerceSellableItemSearchResultItem>()
.Where(item => item.CommerceSearchItemType == searchItemType)
.Where(item => item.Language == Context.Language.Name);
return(searchResultItems);
}
}
public static SearchResponse GetNavigationCategories(string navigationDataSource, CommerceSearchOptions searchOptions)
{
ID navigationId;
var searchManager = CommerceTypeLoader.CreateInstance <ICommerceSearchManager>();
var searchIndex = searchManager.GetIndex();
if (navigationDataSource.IsGuid())
{
navigationId = ID.Parse(navigationDataSource);
}
else
{
using (var context = searchIndex.CreateSearchContext())
{
var query = LinqHelper.CreateQuery <Sitecore.ContentSearch.SearchTypes.SitecoreUISearchResultItem>(context, SearchStringModel.ParseDatasourceString(navigationDataSource))
.Select(result => result.GetItem().ID);
if (query != null & query.Any())
{
navigationId = query.First();
}
else
{
return(new SearchResponse());
}
}
}
using (var context = searchIndex.CreateSearchContext())
{
var searchResults = context.GetQueryable <CommerceBaseCatalogSearchResultItem>()
.Where(item => item.CommerceSearchItemType == CommerceSearchResultItemType.Category)
.Where(item => item.Language == CurrentLanguageName)
.Where(item => item.CommerceAncestorIds.Contains(navigationId))
.Select(p => new CommerceBaseCatalogSearchResultItem()
{
ItemId = p.ItemId,
Uri = p.Uri
});
searchResults = searchManager.AddSearchOptionsToQuery <CommerceBaseCatalogSearchResultItem>(searchResults, searchOptions);
var results = searchResults.GetResults();
var response = SearchResponse.CreateFromSearchResultsItems(searchOptions, results);
return(response);
}
}
/// <summary>
/// Merges the carts.
/// </summary>
/// <param name="storefront">The storefront.</param>
/// <param name="visitorContext">The visitor context.</param>
/// <param name="anonymousVisitorId">The anonymous visitor identifier.</param>
/// <param name="anonymousVisitorCart">The anonymous visitor cart.</param>
/// <returns>
/// The manager response where the merged cart is returned in the result.
/// </returns>
public virtual ManagerResponse <CartResult, CommerceCart> MergeCarts([NotNull] CommerceStorefront storefront, [NotNull] VisitorContext visitorContext, string anonymousVisitorId, Cart anonymousVisitorCart)
{
Assert.ArgumentNotNull(storefront, "storefront");
Assert.ArgumentNotNull(visitorContext, "visitorContext");
Assert.ArgumentNotNullOrEmpty(anonymousVisitorId, "anonymousVisitorId");
var userId = visitorContext.UserId;
var cartResult = this.LoadCartByName(storefront.ShopName, storefront.DefaultCartName, userId, true);
if (!cartResult.Success || cartResult.Cart == null)
{
var message = StorefrontManager.GetSystemMessage(StorefrontConstants.SystemMessages.CartNotFoundError);
cartResult.SystemMessages.Add(new SystemMessage {
Message = message
});
return(new ManagerResponse <CartResult, CommerceCart>(cartResult, cartResult.Cart as CommerceCart));
}
CommerceCart currentCart = (CommerceCart)cartResult.Cart;
var result = new CartResult {
Cart = currentCart, Success = true
};
if (userId != anonymousVisitorId)
{
var anonymousCartHasPromocodes = (anonymousVisitorCart is CommerceCart) &&
((CommerceCart)anonymousVisitorCart).OrderForms.Any(of => of.PromoCodes.Any());
if (anonymousVisitorCart != null && (anonymousVisitorCart.Lines.Any() || anonymousCartHasPromocodes))
{
if ((currentCart.ShopName == anonymousVisitorCart.ShopName) || (currentCart.ExternalId != anonymousVisitorCart.ExternalId))
{
var mergeCartRequest = new MergeCartRequest(anonymousVisitorCart, currentCart);
result = this.CartServiceProvider.MergeCart(mergeCartRequest);
}
}
}
if (result.Success && result.Cart != null)
{
var cartCache = CommerceTypeLoader.CreateInstance <CartCacheHelper>();
cartCache.InvalidateCartCache(anonymousVisitorId);
cartCache.AddCartToCache(result.Cart as CommerceCart);
}
return(new ManagerResponse <CartResult, CommerceCart>(result, result.Cart as CommerceCart));
}
/// <summary>
/// Changes the line quantity.
/// </summary>
/// <param name="storefront">The storefront.</param>
/// <param name="visitorContext">The visitor context.</param>
/// <param name="inputModel">The input model.</param>
/// <returns>
/// The manager response where the modified CommerceCart is returned in the Result.
/// </returns>
public virtual ManagerResponse <CartResult, CommerceCart> ChangeLineQuantity([NotNull] CommerceStorefront storefront, [NotNull] VisitorContext visitorContext, [NotNull] UpdateCartLineInputModel inputModel)
{
Assert.ArgumentNotNull(inputModel, "inputModel");
Assert.ArgumentNotNullOrEmpty(inputModel.ExternalCartLineId, "inputModel.ExternalCartLineId");
var cartResult = this.LoadCartByName(storefront.ShopName, storefront.DefaultCartName, visitorContext.UserId);
if (!cartResult.Success || cartResult.Cart == null)
{
var message = StorefrontManager.GetSystemMessage(StorefrontConstants.SystemMessages.CartNotFoundError);
cartResult.SystemMessages.Add(new SystemMessage {
Message = message
});
return(new ManagerResponse <CartResult, CommerceCart>(cartResult, cartResult.Cart as CommerceCart));
}
var cartCache = CommerceTypeLoader.CreateInstance <CartCacheHelper>();
cartCache.InvalidateCartCache(visitorContext.GetCustomerId());
var cart = cartResult.Cart;
var result = new CartResult {
Cart = cart, Success = true
};
var cartLineToChange = cart.Lines.SingleOrDefault(cl => cl.Product != null && cl.ExternalCartLineId == inputModel.ExternalCartLineId);
if (inputModel.Quantity == 0 && cartLineToChange != null)
{
result = this.RemoveCartLines(cart, new[] { cartLineToChange }, true);
}
else if (cartLineToChange != null)
{
cartLineToChange.Quantity = inputModel.Quantity;
var request = new UpdateCartLinesRequest(cart, new[] { cartLineToChange });
request.RefreshCart(true);
result = this.CartServiceProvider.UpdateCartLines(request);
}
if (result.Success && result.Cart != null)
{
cartCache.AddCartToCache(result.Cart as CommerceCart);
}
this.AddBasketErrorsToResult(result.Cart as CommerceCart, result);
return(new ManagerResponse <CartResult, CommerceCart>(result, result.Cart as CommerceCart));
}
/// <summary>
/// Gets the child variants read only.
/// </summary>
/// <param name="itemId">The item identifier.</param>
/// <param name="language">The language.</param>
/// <returns>Product variant collection.</returns>
private IEnumerable <Variant> GetChildVariantsReadOnly(ID itemId, string language)
{
var catalogRepository = CommerceTypeLoader.CreateInstance <ICatalogRepository>();
var externalInfo = catalogRepository.GetExternalIdInformation(itemId.Guid);
if (externalInfo != null && externalInfo.CommerceItemType == CommerceItemType.ProductFamily)
{
var culture = CommerceUtility.ConvertLanguageToCulture(language);
var productFamily = catalogRepository.GetProductReadOnly(externalInfo.CatalogName, externalInfo.ProductId, culture) as ProductFamily;
if (productFamily != null && productFamily.Variants.Count > 0)
{
return(productFamily.Variants);
}
}
return(new List <Variant>());
}
/// <summary>
/// Removes the line item from cart.
/// </summary>
/// <param name="storefront">The storefront.</param>
/// <param name="visitorContext">The visitor context.</param>
/// <param name="externalCartLineId">The external cart line identifier.</param>
/// <returns>
/// The manager response where the modified CommerceCart is returned in the Result.
/// </returns>
public virtual ManagerResponse <CartResult, CommerceCart> RemoveLineItemFromCart([NotNull] CommerceStorefront storefront, [NotNull] VisitorContext visitorContext, [NotNull] string externalCartLineId)
{
Assert.ArgumentNotNullOrEmpty(externalCartLineId, "externalCartLineId");
var cartResult = this.LoadCartByName(storefront.ShopName, storefront.DefaultCartName, visitorContext.UserId, false);
if (!cartResult.Success || cartResult.Cart == null)
{
var message = StorefrontManager.GetSystemMessage(StorefrontConstants.SystemMessages.CartNotFoundError);
cartResult.SystemMessages.Add(new SystemMessage
{
Message = message
});
return(new ManagerResponse <CartResult, CommerceCart>(cartResult, cartResult.Cart as CommerceCart));
}
var cartCache = CommerceTypeLoader.CreateInstance <CartCacheHelper>();
cartCache.InvalidateCartCache(visitorContext.GetCustomerId());
CommerceCart cart = cartResult.Cart as CommerceCart;
var lineToRemove = cart.Lines.SingleOrDefault(cl => cl.ExternalCartLineId == externalCartLineId);
if (lineToRemove == null)
{
return(new ManagerResponse <CartResult, CommerceCart>(new CartResult {
Success = true
}, cart));
}
var removeLinesRequest = new RemoveCartLinesRequest(cart, new[] { new CartLine {
ExternalCartLineId = externalCartLineId, Quantity = lineToRemove.Quantity, Product = lineToRemove.Product
} });
removeLinesRequest.RefreshCart(true);
var removeLinesResult = this.CartServiceProvider.RemoveCartLines(removeLinesRequest);
if (removeLinesResult.Success && removeLinesResult.Cart != null)
{
cartCache.AddCartToCache(removeLinesResult.Cart as CommerceCart);
}
Helpers.LogSystemMessages(removeLinesResult.SystemMessages, removeLinesResult);
return(new ManagerResponse <CartResult, CommerceCart>(removeLinesResult, removeLinesResult.Cart as CommerceCart));
}
/// <summary>
/// Determines whether this instance [can line item be emailed] the specified line item.
/// </summary>
/// <param name="lineItem">The line item.</param>
/// <returns>True if the line item can be emailed; otherwise false.</returns>
protected virtual bool CanLineItemBeEmailed(CommerceCartLine lineItem)
{
bool lineItemCanBeEmailed = true;
var product = (CommerceCartProduct)lineItem.Product;
var repository = CommerceTypeLoader.CreateInstance <ICatalogRepository>();
CSCatalog.Product commerceProduct = repository.GetProduct(product.ProductCatalog, product.ProductId);
if (commerceProduct != null)
{
if (!commerceProduct.DefinitionName.Equals("GiftCard", StringComparison.OrdinalIgnoreCase))
{
lineItemCanBeEmailed = false;
}
}
return(lineItemCanBeEmailed);
}
private IEnumerable <Sitecore.Data.Items.Item> GetChildCategories(ID categorySitecoreId)
{
var searchManager = CommerceTypeLoader.CreateInstance <ICommerceSearchManager>();
var searchIndex = searchManager.GetIndex();
// TODO: I replicated this from the SXA storefront code.
// Seems a strange way to get the child categories to me.
// Why not use ParentCategoryList to query in the index, need to investigate.
using (var context = searchIndex.CreateSearchContext())
{
var category = context.GetQueryable <CommerceCategorySearchResultItem>()
.Where(x => x.ItemId == categorySitecoreId)
.Where(x => x.Language == Sitecore.Context.Language.Name)
.ToList();
if (category.Count() == 0)
{
return(null);
}
var childrenCategories = String.Empty;
try
{
childrenCategories = category[0]["childrencategorylist"];
}
catch (KeyNotFoundException)
{
Sitecore.Diagnostics.Log.Info($"No children categories found for {category[0].DisplayName}", this);
}
if (string.IsNullOrEmpty(childrenCategories))
{
return(null);
}
var childrenCategoryIds = childrenCategories.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
return(childrenCategoryIds
.Select(x => Sitecore.Context.Database.GetItem(new ID(x))));
}
}
/// <summary>
/// Initilizes the specified shipping methods.
/// </summary>
/// <param name="shippingMethods">The shipping methods.</param>
public virtual void Initialize(IEnumerable <ShippingMethod> shippingMethods)
{
if (shippingMethods == null)
{
return;
}
var shippingMethodList = new List <ShippingMethodBaseJsonResult>();
foreach (var shippingMethod in shippingMethods)
{
var jsonResult = CommerceTypeLoader.CreateInstance <ShippingMethodBaseJsonResult>();
jsonResult.Initialize(shippingMethod);
shippingMethodList.Add(jsonResult);
}
this.ShippingMethods = shippingMethodList;
}
/// <summary>
/// Initializes the shipping options.
/// </summary>
/// <param name="shippingOptions">The shipping options.</param>
public virtual void InitializeShippingOptions(IEnumerable <ShippingOption> shippingOptions)
{
if (shippingOptions == null)
{
return;
}
var shippingOptionList = new List <ShippingOptionBaseJsonResult>();
foreach (var shippingOption in shippingOptions)
{
var jsonResult = CommerceTypeLoader.CreateInstance <ShippingOptionBaseJsonResult>();
jsonResult.Initialize(shippingOption);
shippingOptionList.Add(jsonResult);
}
this.OrderShippingOptions = shippingOptionList;
}
/// <summary>
/// This method returns the dynamicly generated URL based on the item type.
/// </summary>
/// <param name="item">The item</param>
/// <param name="options">The options</param>
/// <returns>The dynamically built URL</returns>
public override string GetDynamicUrl(Item item, LinkUrlOptions options)
{
Assert.ArgumentNotNull(item, "item");
Assert.ArgumentNotNull(options, "options");
var url = string.Empty;
var searchManager = CommerceTypeLoader.CreateInstance <ICommerceSearchManager>();
if (this.UseShopLinks)
{
if (searchManager.IsItemProduct(item))
{
url = CatalogUrlManager.BuildProductShopLink(item, this.IncludeCatalog, this.IncludeFriendlyName, true);
}
else if (searchManager.IsItemCategory(item))
{
url = CatalogUrlManager.BuildCategoryShopLink(item, this.IncludeCatalog, this.IncludeFriendlyName);
}
else if (this.UseShopLinks && searchManager.IsItemVariant(item))
{
url = CatalogUrlManager.BuildVariantShopLink(item, this.IncludeCatalog, this.IncludeFriendlyName, true);
}
}
else
{
if (searchManager.IsItemProduct(item))
{
url = CatalogUrlManager.BuildProductLink(item, this.IncludeCatalog, this.IncludeFriendlyName);
}
else if (searchManager.IsItemCategory(item))
{
url = CatalogUrlManager.BuildCategoryLink(item, this.IncludeCatalog, this.IncludeFriendlyName);
}
}
if (string.IsNullOrEmpty(url))
{
url = base.GetDynamicUrl(item, options);
}
return(url);
}
/// <summary>
/// Adds the party.
/// </summary>
/// <param name="party">The party.</param>
/// <param name="entityName">Name of the entity.</param>
/// <param name="cartContext">The cart context.</param>
/// <returns>
/// The commerce party that was added.
/// </returns>
protected virtual ConnectOrderModels.CommerceParty AddParty(Party party, string entityName, CartPipelineContext cartContext)
{
OrderAddress destinationAddress = CommerceTypeLoader.CreateInstance <OrderAddress>(new object[] { this.GetPartyName(party), party.ExternalId });
RefSFArguments.TranslateEntityToOrderAddressRequest translateRequest = new RefSFArguments.TranslateEntityToOrderAddressRequest(party, destinationAddress);
var translateResult = PipelineUtility.RunCommerceConnectPipeline <RefSFArguments.TranslateEntityToOrderAddressRequest, TranslateEntityToOrderAddressResult>(PipelineNames.TranslateEntityToOrderAddress, translateRequest);
OrderAddress newOrderAddress = translateResult.Address;
cartContext.Basket.Addresses.Add(newOrderAddress);
ConnectOrderModels.CommerceParty translatedParty = this.EntityFactory.Create <ConnectOrderModels.CommerceParty>(entityName);
Assert.ArgumentNotNull(translatedParty, "translatedParty");
RefSFArguments.TranslateOrderAddressToEntityRequest translateOrderAddressRequest = new RefSFArguments.TranslateOrderAddressToEntityRequest(newOrderAddress, translatedParty);
PipelineUtility.RunCommerceConnectPipeline <RefSFArguments.TranslateOrderAddressToEntityRequest, CommerceResult>(PipelineNames.TranslateOrderAddressToEntity, translateOrderAddressRequest);
return(translatedParty);
}
/// <summary>
/// Initilizes the specified shipping methods.
/// </summary>
/// <param name="shippingMethods">The shipping methods.</param>
/// <param name="shippingMethodsPerItem">The shipping methods per item.</param>
public virtual void Initialize(IEnumerable <ShippingMethod> shippingMethods, IEnumerable <ShippingMethodPerItem> shippingMethodsPerItem)
{
base.Initialize(shippingMethods);
if (shippingMethodsPerItem != null && shippingMethodsPerItem.Any())
{
var lineShippingMethodList = new List <ShippingMethodPerItemBaseJsonResult>();
foreach (var shippingMethodPerItem in shippingMethodsPerItem)
{
var jsonResult = CommerceTypeLoader.CreateInstance <ShippingMethodPerItemBaseJsonResult>();
jsonResult.Initialize(shippingMethodPerItem);
lineShippingMethodList.Add(jsonResult);
}
this.LineShippingMethods = lineShippingMethodList;
}
}
private void AddShippingMethodsToResult(CheckoutDataBaseJsonResult result)
{
var shippingMethodJsonResult = CommerceTypeLoader.CreateInstance <ShippingMethodBaseJsonResult>();
var response = this.ShippingManager.GetShippingMethods(this.CurrentStorefront, this.CurrentVisitorContext, new ShippingOption {
ShippingOptionType = ShippingOptionType.ElectronicDelivery
});
if (response.ServiceProviderResult.Success && response.Result.Count > 0)
{
shippingMethodJsonResult.Initialize(response.Result.ElementAt(0));
result.EmailDeliveryMethod = shippingMethodJsonResult;
return;
}
var shippingToStoreJsonResult = CommerceTypeLoader.CreateInstance <ShippingMethodBaseJsonResult>();
result.EmailDeliveryMethod = shippingMethodJsonResult;
result.ShipToStoreDeliveryMethod = shippingToStoreJsonResult;
result.SetErrors(response.ServiceProviderResult);
}
/// <summary>
/// Gets the product information from the index file.
/// </summary>
/// <param name="catalogName">Name of the catalog.</param>
/// <param name="productIdList">The product identifier list.</param>
/// <returns>
/// The found product document instance; Otherwise null.
/// </returns>
protected virtual List <PriceSearchResultItem> GetProductsFromIndex(String catalogName, IEnumerable <string> productIdList)
{
var searchManager = CommerceTypeLoader.CreateInstance <ICommerceSearchManager>();
var searchIndex = searchManager.GetIndex();
var productPredicate = this.BuildProductIdListPredicate(productIdList);
using (var context = searchIndex.CreateSearchContext())
{
var searchResults = context.GetQueryable <PriceSearchResultItem>()
.Where(item => item.CommerceSearchItemType == CommerceSearchResultItemType.Product)
.Where(item => item.CatalogName == catalogName)
.Where(item => item.Language == Sitecore.Context.Language.Name)
.Where(productPredicate)
.Select(p => new PriceSearchResultItem {
OtherFields = p.Fields, ListPrice = p.ListPrice, BasePrice = p.BasePrice, VariantInfo = p.VariantInfo, Name = p.Name
});
return(searchResults.ToList());
}
}
/// <summary>
/// Executes a search in a bucket to retrieve catalog items.
/// </summary>
/// <param name="defaultBucketQuery">The search default bucket query value.</param>
/// <param name="persistentBucketFilter">The search persistent bucket filter value.</param>
/// <returns>A list of catalog items.</returns>
public static SearchResponse SearchBucketForCatalogItems(string defaultBucketQuery, string persistentBucketFilter)
{
var searchManager = CommerceTypeLoader.CreateInstance <ICommerceSearchManager>();
var searchIndex = searchManager.GetIndex();
var defaultQuery = defaultBucketQuery.Replace("&", ";");
var persistentQuery = persistentBucketFilter.Replace("&", ";");
var combinedQuery = CombineQueries(persistentQuery, defaultQuery);
var searchStringModel = SearchStringModel.ParseDatasourceString(combinedQuery);
using (var context = searchIndex.CreateSearchContext(SearchSecurityOptions.EnableSecurityCheck))
{
var query = LinqHelper.CreateQuery <Sitecore.ContentSearch.SearchTypes.SitecoreUISearchResultItem>(context, searchStringModel)
.Where(item => item.Language == SearchNavigation.CurrentLanguageName);
var results = query.GetResults();
var response = SearchResponse.CreateFromUISearchResultsItems(new CommerceSearchOptions(), results);
return(response);
}
}
/// <summary>
/// Returns the current user cart.
/// </summary>
/// <param name="storefront">The storefront.</param>
/// <param name="customerId">The customer identifier.</param>
/// <param name="refresh">if set to <c>true</c> [refresh].</param>
/// <returns>
/// The manager response where the modified CommerceCart is returned in the Result.
/// </returns>
public virtual ManagerResponse <CartResult, CommerceCart> GetCurrentCart([NotNull] CommerceStorefront storefront, [NotNull] string customerId, bool refresh = false)
{
var cartCache = CommerceTypeLoader.CreateInstance <CartCacheHelper>();
if (refresh)
{
cartCache.InvalidateCartCache(customerId);
}
var cart = cartCache.GetCart(customerId);
if (cart != null)
{
var result = new CartResult {
Cart = cart
};
this.AddBasketErrorsToResult(result.Cart as CommerceCart, result);
return(new ManagerResponse <CartResult, CommerceCart>(result, cart));
}
CartResult cartResult = this.LoadCartByName(storefront.ShopName, storefront.DefaultCartName, customerId, refresh);
if (cartResult.Success && cartResult.Cart != null)
{
cart = cartResult.Cart as CommerceCart;
cartResult.Cart = cart;
cartCache.AddCartToCache(cart);
}
else
{
var message = StorefrontManager.GetSystemMessage(StorefrontConstants.SystemMessages.CartNotFoundError);
cartResult.SystemMessages.Add(new SystemMessage {
Message = message
});
}
this.AddBasketErrorsToResult(cartResult.Cart as CommerceCart, cartResult);
return(new ManagerResponse <CartResult, CommerceCart>(cartResult, cart));
}
public SearchResults GetProducts(
string catalogName,
ID categoryId,
CommerceSearchOptions searchOptions,
string searchKeyword)
{
Assert.ArgumentNotNull(catalogName, nameof(catalogName));
var commerceSearchManager = CommerceTypeLoader.CreateInstance <ICommerceSearchManager>();
var queryable = this.GetBaseQueryable(catalogName, ProductCommerceSearchItemType);
if (!ID.IsNullOrEmpty(categoryId))
{
queryable = queryable.Where(x => x.CommerceAncestorIds.Contains(categoryId));
}
if (!string.IsNullOrEmpty(searchKeyword))
{
queryable = queryable.Where(item => item.Name.Contains(searchKeyword) || item["_displayname"].Contains(searchKeyword));
}
queryable = commerceSearchManager.AddSearchOptionsToQuery(queryable, searchOptions);
var results = queryable.GetResults();
var searchResultsItems = SearchResponse.CreateFromSearchResultsItems(searchOptions, results);
if (searchResultsItems != null)
{
return(new SearchResults(
searchResultsItems.ResponseItems,
searchResultsItems.TotalItemCount,
searchResultsItems.TotalPageCount,
searchOptions.StartPageIndex,
searchResultsItems.Facets.ToList()));
}
return(new SearchResults());
}
/// <summary>
/// Runs the processor.
/// </summary>
/// <param name="args">The args.</param>
public virtual void Process(PipelineArgs args)
{
if (Context.Item != null)
{
return;
}
var routeData = this.GetCatalogItemFromIncomingRequest();
if (routeData != null)
{
var siteContext = CommerceTypeLoader.CreateInstance <ISiteContext>();
Context.Item = ResolveCatalogItem(routeData.Id, routeData.Catalog, routeData.IsProduct);
siteContext.CurrentCatalogItem = Context.Item;
if (Context.Item == null)
{
WebUtil.Redirect("~/");
}
}
}
/// <summary>
/// Initializes this object based on the data contained in the provided cart.
/// </summary>
/// <param name="cart">The cart used to initialize this object.</param>
public virtual void Initialize(Cart cart)
{
this.Lines = new List <CartLineBaseJsonResult>();
this.Adjustments = new List <CartAdjustmentBaseJsonResult>();
this.PromoCodes = new List <string>();
var currencyCode = StorefrontManager.GetCustomerCurrency();
this.Subtotal = 0.0M.ToCurrency(currencyCode);
this.TaxTotal = 0.0M.ToCurrency(currencyCode);
this.Total = 0.0M.ToCurrency(currencyCode);
this.TotalAmount = 0.0M;
this.Discount = 0.0M.ToCurrency(currencyCode);
this.ShippingTotal = 0.0M.ToCurrency(currencyCode);
if (cart == null)
{
return;
}
foreach (var line in (cart.Lines ?? Enumerable.Empty <CartLine>()))
{
var cartLine = CommerceTypeLoader.CreateInstance <CartLineBaseJsonResult>(line);
this.Lines.Add(cartLine);
}
foreach (var adjustment in (cart.Adjustments ?? Enumerable.Empty <CartAdjustment>()))
{
this.Adjustments.Add(new CartAdjustmentBaseJsonResult(adjustment));
}
var commerceTotal = (CommerceTotal)cart.Total;
this.Subtotal = commerceTotal.Subtotal.ToCurrency(currencyCode);
this.TaxTotal = cart.Total.TaxTotal.Amount.ToCurrency(currencyCode);
this.Total = cart.Total.Amount.ToCurrency(currencyCode);
this.TotalAmount = cart.Total.Amount;
this.Discount = commerceTotal.OrderLevelDiscountAmount.ToCurrency(currencyCode);
this.ShippingTotal = commerceTotal.ShippingTotal.ToCurrency(currencyCode);
}