public RecommendationGroup BuildKaChingRecommendationGroup(
ContentReference entryLink,
ICollection <Association> associations)
{
IDictionary <ContentReference, EntryContentBase> entriesByContentLink = _contentLoader
.GetItems(
associations.Select(x => x.Target).Concat(new[] { entryLink }),
CultureInfo.InvariantCulture)
.OfType <EntryContentBase>()
.ToDictionary(x => x.ContentLink);
if (!entriesByContentLink.TryGetValue(entryLink, out EntryContentBase entry))
{
return(null);
}
ICollection <string> childCodes = new List <string>(associations.Count);
foreach (var targetRef in associations.Select(a => a.Target))
{
if (!entriesByContentLink.TryGetValue(targetRef, out EntryContentBase childEntry))
{
continue;
}
childCodes.Add(childEntry.Code.SanitizeKey());
}
return(new RecommendationGroup
{
ProductId = entry.Code.SanitizeKey(),
Recommendations = childCodes
});
}
public IEnumerable <FashionVariant> GetVariations(FashionProduct currentContent)
{
return(_contentLoader
.GetItems(currentContent.GetVariants(_relationRepository), _preferredCulture)
.Cast <FashionVariant>()
.Where(v => v.IsAvailableInCurrentMarket(_currentMarket)));
}
public IEnumerable <ProductTileViewModel> GetProductTileViewModels(IEnumerable <ContentReference> entryLinks)
{
var language = _languageService.GetCurrentLanguage();
var contentItems = _contentLoader.GetItems(entryLinks, language);
return(contentItems.OfType <EntryContentBase>().Select(x => x.GetProductTileViewModel(_currentMarket.GetCurrentMarket(), _currencyService.GetCurrentCurrency())));
}
private IEnumerable <FashionVariant> GetVariants(PackageContent currentContent)
{
return(_contentLoader
.GetItems(currentContent.GetEntries(_relationRepository), _languageResolver.GetPreferredCulture())
.OfType <FashionVariant>()
.Where(v => v.IsAvailableInCurrentMarket(_currentMarket) && !_filterPublished.ShouldFilter(v))
.ToArray());
}
private IEnumerable <FashionVariant> GetVariants(IEnumerable <FashionProduct> products, CultureInfo language)
{
var variants = products
.SelectMany(x => _contentLoader.GetItems(x.GetVariants(_relationRepository), language)
.OfType <FashionVariant>());
return(variants);
}
public virtual IEnumerable <ContentIndexingResult> IndexFrom(ContentReference contentLink)
{
var mainContent = ContentLoader.Get <IContent>(contentLink);
var contentReferencesToIndex = ContentLoader.GetDescendents(contentLink);
var contentsToIndex = ContentLoader.GetItems(contentReferencesToIndex, CultureInfo.InvariantCulture).ToList();
// Add main content to list
contentsToIndex.Insert(0, mainContent);
return(ContentIndexer.Index(contentsToIndex));
}
public virtual MyProductVM GetProductViewModel(ProductContent product)
{
var variations = _contentLoader.GetItems(product.GetVariants(), _preferredCulture).
Cast <VariationContent>()
.ToList();
var variation = variations.FirstOrDefault();
var productVM = new MyProductVM();
productVM.Name = variation.Name;
productVM.Link = variation.GetUrl();
return(productVM);
}
public static IEnumerable <VariationContent> VariationContents(this ProductContent productContent,
IContentLoader contentLoader, IRelationRepository relationRepository)
{
return
(contentLoader.GetItems(productContent.GetVariants(relationRepository), productContent.Language)
.OfType <VariationContent>());
}
private IDictionary <string, int> GetStatusCount(int projectId)
{
var statuses = StatusList.ToDictionary(di => di.Key, di => di.Value); //clone the dictionary
var versionableItems = _contentLoader.GetItems(_projectRepository.ListItems(projectId).Select(i => i.ContentLink),
LanguageSelector.AutoDetect()).OfType <IVersionable>();
foreach (var versionableItem in versionableItems)
{
var status = HasExpired(versionableItem) ? ExtendedVersionStatus.Expired : (ExtendedVersionStatus)versionableItem.Status;
var key = status.ToString().ToLowerInvariant();
var contentItem = (IContent)versionableItem;
var isDeleted = contentItem.IsDeleted;
var hasEditAccess = _contentLoaderService.HasEditAccess(contentItem, AccessLevel.Publish);
if (isDeleted || !hasEditAccess)
{
key += NoAccesKey;
}
statuses[key]++;
}
return(statuses);
}
//#endregion // new stuff
public void CheckOnParentAndNode()
{
List <ContentReference> theList = new List <ContentReference>();
var shirt = _refConv.GetContentLink("Long Sleeve Shirt White Small_1");
var noProdParent = _refConv.GetContentLink("PriceTest_1");
var Pack = _refConv.GetContentLink("SomePackage_1");
var Prod = _refConv.GetContentLink("Shirt-Long-Sleeve_1");
var node = _refConv.GetContentLink("Shirts_1");
theList.Add(shirt); // parent = node, ...typeId "Variation" ... no children
theList.Add(noProdParent); // parent = node ...typeId "Variation" ... no children
theList.Add(Pack); // parent = node ...typeId "Package" ... no children
theList.Add(Prod); //parent = node...typeId ""...no children
theList.Add(node);
// check ...TypeId - string/int
var rel = new NodeEntryRelation
{
// IsPrimary
// TargetCatalog
};
var rel2 = new PackageEntry
{
//GroupName
//Quantity
//SortOrder
};
var stuff = _contentLoader.GetItems(theList, new LoaderOptions());
foreach (var item in stuff)
{
var Parent = _contentLoader.Get <CatalogContentBase>(item.ParentLink);
// new...
var children = _contentLoader.GetChildren <CatalogContentBase>(item.ContentLink);
var ii = item.GetOriginalType().Name; // "ShirtVariation" ... have FullName also
if (item is EntryContentBase) // use this, checks "the tree"
{
var ParentPackages = // Smashing on the node... of course - "Wrong base class"
_contentLoader.Get <EntryContentBase>(item.ContentLink).GetParentPackages();
var ParentProducts =
_contentLoader.Get <EntryContentBase>(item.ContentLink).GetParentProducts();
var ParentEntries =
_contentLoader.Get <EntryContentBase>(item.ContentLink).GetParentEntries();
var ParentCategories =
_contentLoader.Get <EntryContentBase>(item.ContentLink).GetCategories();
}
}
// Can do like this now, not tested yet
//var children2 = _relationRepository.GetChildren<NodeEntryRelation>(parentLink);
}
public IEnumerable <EntryContentBase> GetVariants(ProductContent content)
{
var variants = content.GetVariants();
var variantItems = _contentLoader.GetItems(variants, LanguageSelector.AutoDetect());
return(FilterForVisitor.Filter(variantItems).OfType <EntryContentBase>());
}
private IEnumerable <SearchResult> CreateSearchResults(IEnumerable <EntryContentBase> documents, string keyword)
{
var culture = _languageResolver.GetPreferredCulture();
var references = documents.Select(_ => _.ContentLink)
.ToList();
var childReferences = documents.OfType <GenericProduct>()
.SelectMany(x => x.Variations())
.Select(x => x)
.ToList();
var entries = _contentLoader.GetItems(childReferences, culture)
.OfType <EntryContentBase>()
.Where(x => x.Name.IndexOf(keyword, StringComparison.OrdinalIgnoreCase) >= 0 ||
x.Code.IndexOf(keyword, StringComparison.OrdinalIgnoreCase) >= 0);
foreach (var entry in documents)
{
yield return(CreateMySearchResult(entry));
}
foreach (var entry in entries)
{
yield return(CreateMySearchResult(entry));
}
}
public override ActionResult Index(CarouselBlock currentBlock)
{
var model = new CarouselBlockViewModel(currentBlock);
foreach (var item in _contentLoader.GetItems(currentBlock.CarouselItems, _languageResolver.GetPreferredCulture()))
{
if (item.GetOriginalType().Equals(typeof(ImageMediaData)))
{
var image = _contentLoader.Get <ImageMediaData>(item.ContentLink);
var carouselImage = new CarouselImage()
{
Heading = image.Title,
Description = image.Description,
Image = image.ContentLink
};
model.Items.Add(new CarouselItem()
{
CarouselImage = carouselImage
});
}
else if (item.GetOriginalType().Equals(typeof(HeroBlock)))
{
var heroBlock = _contentLoader.Get <HeroBlock>(item.ContentLink);
model.Items.Add(new CarouselItem()
{
HeroBlock = new BlockViewModel <HeroBlock>(heroBlock)
});
}
}
return(PartialView("~/Features/Blocks/Views/CarouselBlock.cshtml", model));
}
private IEnumerable <FashionVariant> GetVariations(FashionProduct currentContent)
{
return(_contentLoader
.GetItems(currentContent.GetVariants(_relationRepository), _languageResolver.GetPreferredCulture())
.Cast <FashionVariant>()
.Where(v => v.IsAvailableInCurrentMarket(_currentMarket) && !_filterPublished.ShouldFilter(v)));
}
public Task <VariantsResponce> Handle(VariantsRequest request, CancellationToken cancellationToken)
{
var variationReferences = _relationRepository.GetChildren <ProductVariation>(request.ProductReference);
var variations = _contentLoader.GetItems(variationReferences.Select(x => x.Child), new LoaderOptions {
LanguageLoaderOption.FallbackWithMaster()
}).OfType <MovieVariant>();
var prices = _customerPriceService.GetPrices(variations.Select(x => x.Code)).ToDictionary(x => x.CatalogKey.CatalogEntryCode, y => y);
var discount = _customerPriceService.GetDiscountPrices(variations.Select(x => x.ContentLink)).ToDictionary(x => x.EntryLink, y => y.DiscountPrices);
var result = variations.Select(x => new Variant()
{
Code = x.Code,
Name = x.Name,
Primary = x.IsPrimary,
DisplayName = x.MediaTypes,
NormalPrice = prices.GetPrice(x.Code),
Discounts = discount.GetDiscounts(x.ContentLink)
}).ToList();
var responce = new VariantsResponce()
{
Variants = result
};
if (string.IsNullOrEmpty(request.CurrentVariantCode))
{
responce.ActiveVariant = result.Where(x => x.Primary).FirstOrDefault();
}
else
{
responce.ActiveVariant = result.Where(x => x.Code == request.CurrentVariantCode).FirstOrDefault();
}
return(Task.FromResult(responce));
}
private IEnumerable <BaseVariant> GetVariations(BaseProduct currentContent)
{
return(_contentLoader
.GetItems(currentContent.GetVariants(_relationRepository), _preferredCulture)
.Cast <BaseVariant>()
.Where(v => v.IsAvailableInCurrentMarket(_currentMarket) && !_filterPublished.ShouldFilter(v)));
}
public IEnumerable <CartItem> GetCartItems()
{
if (_cardhelper.IsEmpty)
{
return(Enumerable.Empty <CartItem>());
}
var cartItems = new List <CartItem>();
var lineItems = _cardhelper.Cart.GetAllLineItems();
//// In order to show the images for the items in the cart, we need to load the variants
var variants = _contentLoader.GetItems(lineItems.Select(x => _referenceConverter.GetContentLink(x.Code)),
_preferredCulture).OfType <VariationContent>();
foreach (var lineItem in lineItems)
{
VariationContent variant = variants.FirstOrDefault(x => x.Code == lineItem.Code);
ProductContent product = _contentLoader.Get <ProductContent>(variant.GetParentProducts().FirstOrDefault());
CartItem item = new CartItem
{
Code = lineItem.Code,
DisplayName = lineItem.DisplayName,
ImageUrl = variant.GetAssets <IContentImage>(_contentLoader, _urlResolver).FirstOrDefault() ?? "",
Quantity = lineItem.Quantity,
Url = lineItem.GetUrl(),
Variant = variant,
Price = variant.GetPrices().FirstOrDefault().UnitPrice
};
cartItems.Add(item);
}
return(cartItems);
}
protected RestSearchDocument PopulateRestSearchDocument(string code, string language)
{
var contentLink = _referenceConverter.GetContentLink(code);
if (ContentReference.IsNullOrEmpty(contentLink))
{
return(null);
}
var document = new RestSearchDocument();
var entryContent = _contentLoader.Get <EntryContentBase>(contentLink);
var fashionProduct = entryContent as FashionProduct;
var fashionPackage = entryContent as FashionPackage;
if (fashionProduct != null)
{
var variants = _contentLoader.GetItems(fashionProduct.GetVariants(_relationRepository), CultureInfo.GetCultureInfo(language)).OfType <FashionVariant>().ToList();
AddPrices(document, variants.Select(v => new CatalogKey(v.Code)));
AddColors(document, variants);
AddSizes(document, variants);
AddCodes(document, variants);
document.Fields.Add(new RestSearchField("brand", fashionProduct.Brand));
}
else if (fashionPackage != null)
{
AddPrices(document, new [] { new CatalogKey(fashionPackage.Code) });
}
document.Fields.Add(new RestSearchField("code", entryContent.Code, new[] { SearchField.Store.YES, SearchField.IncludeInDefaultSearch.YES }));
document.Fields.Add(new RestSearchField("displayname", entryContent.DisplayName));
document.Fields.Add(new RestSearchField("image_url", _assetUrlResolver.GetAssetUrl <IContentImage>(entryContent)));
document.Fields.Add(new RestSearchField("content_link", entryContent.ContentLink.ToString()));
document.Fields.Add(new RestSearchField("created", entryContent.Created.ToString("yyyyMMddhhmmss")));
document.Fields.Add(new RestSearchField("top_category_name", GetTopCategoryName(entryContent)));
return(document);
}
public IndexingStatus UpdateStructure(IContent root, string indexName)
{
var language = CultureInfo.CurrentCulture;
if (root is ILocale locale && locale.Language != null && !CultureInfo.InvariantCulture.Equals(locale.Language))
{
language = locale.Language;
}
Logger.Information($"Performing recursive update, starting from {root.ContentLink}, in language {language}");
var status = Update(root, indexName);
var descendents = _contentLoader.GetDescendents(root.ContentLink);
var contents = _contentLoader.GetItems(descendents, language);
foreach (var content in contents)
{
var childStatus = Update(content, indexName);
if (childStatus == IndexingStatus.Error && status != IndexingStatus.Error)
{
status = IndexingStatus.PartialError;
}
}
return(status);
}
public virtual IEnumerable <ShipmentViewModel> CreateShipmentsViewModel(ICart cart)
{
foreach (var shipment in cart.GetFirstForm().Shipments)
{
var shipmentModel = new ShipmentViewModel
{
ShipmentId = shipment.ShipmentId,
CartItems = new List <CartItemViewModel>(),
Address = _addressBookService.ConvertToModel(shipment.ShippingAddress),
ShippingMethods = CreateShippingMethodViewModels(cart.Market, cart.Currency, shipment)
};
shipmentModel.ShippingMethodId = shipment.ShippingMethodId == Guid.Empty ? shipmentModel.ShippingMethods.First().Id : shipment.ShippingMethodId;
var variants = _contentLoader.GetItems(shipment.LineItems.Select(x => _referenceConverter.GetContentLink(x.Code)),
_preferredCulture).OfType <VariationContent>();
foreach (var lineItem in shipment.LineItems)
{
var variant = variants.Single(x => x.Code == lineItem.Code);
var productLink = variant.GetParentProducts(_relationRepository).FirstOrDefault();
if (ContentReference.IsNullOrEmpty(productLink))
{
continue;
}
shipmentModel.CartItems.Add(_cartItemViewModelFactory.CreateCartItemViewModel(cart, lineItem, variant));
}
yield return(shipmentModel);
}
}
/// <summary>
/// Returns all the content items of <typeparamref name="T"/> from <paramref name="contentAreaItems"/>
/// </summary>
/// <typeparam name="T">Type of <see cref="IContentData"/> items to extract.</typeparam>
/// <param name="contentAreaItems">The <see cref="IEnumerable{ContentAreaItem}"/> to extract <see cref="IContent"/> instances of type <typeparamref name="T"/> from.</param>
/// <param name="language">The <see cref="CultureInfo"/> to use. If none is specified, current culture will be used.</param>
/// <param name="contentLoader">The <see cref="IContentLoader"/> to use</param>
/// <returns>A <see cref="IEnumerable{T}"/> containing all <see cref="IContent"/> items found in the <paramref name="contentAreaItems"/> collection.</returns>
public static IEnumerable <T> GetContentItems <T>(this IEnumerable <ContentAreaItem> contentAreaItems, CultureInfo language = null,
IContentLoader contentLoader = null)
where T : IContentData
{
if (contentAreaItems == null)
{
return(Enumerable.Empty <T>());
}
if (contentLoader == null)
{
contentLoader = ServiceLocator.Current.GetInstance <IContentLoader>();
}
if (language == null)
{
language = LanguageSelector.AutoDetect().Language;
}
var items = contentLoader.GetItems(contentAreaItems.Select(i => i.ContentLink), language).OfType <T>();
var publishedFilter = new FilterPublished();
var accessFilter = new FilterAccess();
var filterItems = items.OfType <IContent>().Where(x => !publishedFilter.ShouldFilter(x) && !accessFilter.ShouldFilter(x));
return(filterItems.OfType <T>());
}
public override List <Feed> Build()
{
List <Feed> generatedFeeds = new List <Feed>();
Feed feed = GenerateFeedEntity() ?? throw new ArgumentNullException($"{nameof(GenerateFeedEntity)} returned null");
IEnumerable <ContentReference> catalogReferences = _contentLoader.GetDescendents(_referenceConverter.GetRootLink());
IEnumerable <CatalogContentBase> items = _contentLoader.GetItems(catalogReferences, CreateDefaultLoadOption()).OfType <CatalogContentBase>();
List <Entry> entries = new List <Entry>();
foreach (CatalogContentBase catalogContent in items)
{
try
{
Entry entry = GenerateEntry(catalogContent);
if (entry != null)
{
entries.Add(entry);
}
}
catch (Exception ex)
{
_logger.Error($"Failed to generate GoogleProductFeed entry for ContentGuid={catalogContent.ContentGuid}", ex);
}
}
feed.Entries = entries;
generatedFeeds.Add(feed);
return(generatedFeeds);
}
public IList <IPriceDetailValue> List(ContentReference catalogContentReference)
{
var contentToFetchPrices = new List <EntryContentBase>();
var catalogContentItem = _contentLoader.Get <CatalogContentBase>(catalogContentReference);
if (catalogContentItem == null)
{
return(Enumerable.Empty <IPriceDetailValue>().ToList());
}
else if (catalogContentItem is VariationContent)
{
contentToFetchPrices.Add(catalogContentItem as VariationContent);
}
else if (catalogContentItem is ProductContent)
{
contentToFetchPrices.Add(catalogContentItem as ProductContent);
}
else if (catalogContentItem is NodeContent)
{
contentToFetchPrices.AddRange(_contentLoader.GetChildren <EntryContentBase>(catalogContentItem.ContentLink));
}
else if (catalogContentItem is BundleContent)
{
var bundleContent = catalogContentItem as BundleContent;
contentToFetchPrices.AddRange(_contentLoader.GetItems(bundleContent.GetEntries(_relationRepository),
catalogContentItem.Language).OfType <EntryContentBase>());
}
else if (catalogContentItem is PackageContent)
{
var packageContent = catalogContentItem as PackageContent;
contentToFetchPrices.AddRange(_contentLoader.GetItems(packageContent.GetEntries(_relationRepository),
catalogContentItem.Language).OfType <EntryContentBase>());
}
//Get linked variants for any products in our fetch list and add them to the list
var variants = new List <EntryContentBase>();
foreach (var content in contentToFetchPrices)
{
variants.AddRange(GetAttachedVariants(content));
}
contentToFetchPrices.AddRange(variants);
return(InMemoryPriceDatabase.Prices.Where(x => contentToFetchPrices.Select(c => c.Code).Contains(x.Value.CatalogKey.CatalogEntryCode))
.Select(x => x.Value).ToList());
}
public async Task <CartContentResponce> Handle(CartContentRequest request, CancellationToken cancellationToken)
{
var cart = _cartFactory.LoadOrCreateCart();
var allLineItems = cart.GetAllLineItems();
var lineItemCodes = allLineItems.Select(x => x.Code).Distinct();
var variants = _contentLoader.GetItems(_referenceConverter.GetContentLinks(lineItemCodes).Select(x => x.Value), new LoaderOptions {
LanguageLoaderOption.FallbackWithMaster()
}).OfType <MovieVariant>();
var prices = _customerPriceService.GetPrices(variants.Select(x => x.Code)).ToDictionary(x => x.CatalogKey.CatalogEntryCode, x => x);
var discounts = _customerPriceService.GetDiscountPrices(variants.Select(x => x.ContentLink)).ToDictionary(x => x.EntryLink, x => x);
var products = variants.Select(
x => new
{
variant = x.ContentLink,
product = _contentLoader.GetItems(x.GetParentProducts(), new LoaderOptions {
LanguageLoaderOption.FallbackWithMaster()
}).OfType <MovieProduct>()
}).ToDictionary(x => x.variant, x => x.product.FirstOrDefault());
var lineItems = cart.GetAllLineItems().Select(x => new LineItem()
{
Code = x.Code,
DisplayName = x.DisplayName,
Quantity = Convert.ToInt32(x.Quantity),
ImageUrl = "",//products[variants.Where(y => y.Code == x.Code).Select(y => y.ContentLink).First()].PosterPath,
Price = prices[x.Code].UnitPrice.ToString(),
DiscountPrice = discounts[variants.First(y => y.Code == x.Code).ContentLink].DiscountPrices.Last().Price.ToString(),
ProductReference = products[variants.Where(y => y.Code == x.Code).Select(y => y.ContentLink).First()].ContentLink
});
var total = _orderGroupCalculator.GetOrderGroupTotals(cart);
var tax = _orderGroupCalculator.GetTaxTotal(cart);
var orderDiscount = _orderGroupCalculator.GetOrderDiscountTotal(cart);
var lineItemDiscount = new Money(cart.GetAllLineItems().Sum(x => x.GetEntryDiscount()), cart.Currency);
var noDiscount = new Money(allLineItems.Sum(x => prices[x.Code].UnitPrice.Amount * x.Quantity), cart.Currency);
var model = new CartContentResponce()
{
LineItems = lineItems,
Total = total.Total.ToString(),
ItemsDiscount = lineItemDiscount.ToString(),
OrderDiscount = orderDiscount.ToString(),
NoDiscount = noDiscount.ToString()
};
return(await Task.FromResult(model));
}
private ICollection <EntryContentBase> GetEntriesAffected(
EntryContentBase entryContent,
bool includeParentProducts,
bool includeChildVariants)
{
var uniqueLinks = new HashSet <ContentReference>(ContentReferenceComparer.Default);
switch (entryContent)
{
case VariationContent variationContent:
if (includeParentProducts)
{
foreach (ContentReference parentLink in _relationRepository
.GetParents <ProductVariation>(variationContent.ContentLink)
.Select(pv => pv.Parent))
{
uniqueLinks.Add(parentLink);
}
}
break;
case ProductContent productContent:
if (includeChildVariants)
{
foreach (ContentReference childLink in _relationRepository
.GetParents <ProductVariation>(productContent.ContentLink)
.Select(pv => pv.Child))
{
uniqueLinks.Add(childLink);
}
}
uniqueLinks.Add(productContent.ContentLink);
break;
}
ICollection <EntryContentBase> entries = _contentLoader
.GetItems(uniqueLinks, CultureInfo.InvariantCulture)
.OfType <EntryContentBase>()
.ToArray();
return(entries);
}
protected virtual IEnumerable <EntryContentBase> GetEntriesToIndex(int bulkSize, IEnumerable <ContentReference> contentLinks, CultureInfo culture, int skipCount)
{
var items = _contentLoader.GetItems(contentLinks.Skip(skipCount).Take(bulkSize),
new LanguageSelector(culture.Name));
// We only care about entires, not nodes, packages etc.
var entriesToIndex = items.OfType <EntryContentBase>();
return(entriesToIndex);
}
public IEnumerable <EnhancedStructureStoreContentDataModel> GetLatestVersions(IEnumerable <ContentReference> ids,
NameValueCollection queryString)
{
if (ids == null)
{
return(null);
}
var draftLinks = new List <ContentReference>();
foreach (var id in ids)
{
if (_currentProject.ProjectId.HasValue)
{
var projectReference = _projectContentResolver.GetProjectReference(id, _currentProject.ProjectId.Value);
draftLinks.Add(projectReference);
continue;
}
var content = _contentLoader.Get <IContent>(id) as IVersionable;
if (content == null)
{
draftLinks.Add(id);
continue;
}
if (content.Status == VersionStatus.Published)
{
var contentVersion =
_contentVersionRepository.LoadCommonDraft(id, _languageResolver.GetPreferredCulture().Name);
if (contentVersion != null)
{
draftLinks.Add(contentVersion.ContentLink);
continue;
}
}
draftLinks.Add(id);
}
var contents = _contentLoader.GetItems(draftLinks,
new LoaderOptions {
LanguageLoaderOption.FallbackWithMaster()
});
var queryParameters = new ContentQueryParameters
{
AllParameters = queryString,
CurrentPrincipal = PrincipalInfo.CurrentPrincipal
};
// The ContentVersionFilter modify content links.
// We have to use this filter here to make sure that we will use proper links
return(_contentStoreModelCreator
.CreateContentDataStoreModels <EnhancedStructureStoreContentDataModel>(contents, queryParameters).ToList());
}
public IEnumerable <CartItem> GetCartItems()
{
if (CartHelper.IsEmpty)
{
return(Enumerable.Empty <CartItem>());
}
var cartItems = new List <CartItem>();
var lineItems = CartHelper.Cart.GetAllLineItems();
// In order to show the images for the items in the cart, we need to load the variants
var variants = _contentLoader.GetItems(lineItems.Select(x => _referenceConverter.GetContentLink(x.Code)),
_preferredCulture).OfType <VariationContent>();
var marketId = _currentMarket.GetCurrentMarket().MarketId;
var currency = _currencyService.GetCurrentCurrency();
foreach (var lineItem in lineItems)
{
VariationContent variant = variants.FirstOrDefault(x => x.Code == lineItem.Code);
ProductContent product = _contentLoader.Get <ProductContent>(variant.GetParentProducts().FirstOrDefault());
CartItem item = new CartItem
{
Code = lineItem.Code,
DisplayName = lineItem.DisplayName,
ImageUrl = variant.GetAssets <IContentImage>(_contentLoader, _urlResolver).FirstOrDefault() ?? "",
ExtendedPrice = GetExtendedPrice(lineItem, marketId, currency),
PlacedPrice = lineItem.ToMoney(lineItem.PlacedPrice),
DiscountPrice = lineItem.ToMoney(currency.Round(((lineItem.PlacedPrice * lineItem.Quantity) - lineItem.Discounts.Cast <LineItemDiscount>().Sum(x => x.DiscountValue)) / lineItem.Quantity)),
Quantity = lineItem.Quantity,
Url = lineItem.GetUrl(),
Variant = variant,
Discounts = lineItem.Discounts.Cast <LineItemDiscount>().Select(x => new OrderDiscountModel
{
Discount = new Money(x.DiscountAmount, new Currency(CartHelper.Cart.BillingCurrency)),
Displayname = x.DisplayMessage
}),
IsAvailable = _pricingService.GetCurrentPrice(variant.Code).HasValue
};
if (product is FashionProduct)
{
var fashionProduct = (FashionProduct)product;
var fashionVariant = (FashionVariant)variant;
item.Brand = fashionProduct.Brand;
var variations = _productService.GetVariations(fashionProduct);
item.AvailableSizes = variations.Where(x => x.Color == fashionVariant.Color).Select(x => x.Size);
}
cartItems.Add(item);
}
return(cartItems);
}
protected virtual List <IContent> GetDescendentContents(List <ContentReference> contentReferences, IEnumerable <LanguageBranch> languages)
{
var contentItems = new List <IContent>();
foreach (var languageBranch in languages)
{
contentItems.AddRange(_contentLoader.GetItems(contentReferences, languageBranch.Culture));
}
return(contentItems);
}
/// <summary>
/// Gets a list of populated syndication items created from the dependent content references on the gived SyndicationFeedPage.
/// </summary>
/// <returns></returns>
public IEnumerable <SyndicationItem> GetSyndicationItems()
{
var contentReferences = FeedContentResolver.GetContentReferences(FeedContext);
var contentItems = ContentLoader.GetItems(contentReferences, new LoaderOptions {
LanguageLoaderOption.Fallback()
});
var filteredItems = FeedFilterer.FilterSyndicationContent(contentItems, FeedContext);
var syndicationItems = filteredItems.Select(CreateSyndicationItem).ToList();
return(syndicationItems.OrderByDescending(c => c.LastUpdatedTime).Take(FeedContext.FeedPageType.MaximumItems));
}
