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)); }