PersonalizationCarts-CustomTrackingDataFactory.cs

using EPiServer;
using EPiServer.Commerce.Catalog.Linking;
using EPiServer.Commerce.Order;
using EPiServer.Core;
using EPiServer.Globalization;
using EPiServer.ServiceLocation;
using EPiServer.Tracking.Commerce;
using EPiServer.Tracking.Commerce.Data;
using Mediachase.Commerce;
using Mediachase.Commerce.Catalog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web;

namespace Project.CheckoutAndOrderManagement.Implementation.Infrastructure.Tracking
{
    public class CustomTrackingDataFactory : TrackingDataFactory
    {

        private readonly ILineItemCalculator _lineItemCalculator;
        private readonly IContentLoader _contentLoader;
        private readonly IOrderGroupCalculator _orderGroupCalculator;
        private readonly LanguageResolver _languageResolver;
        private readonly IOrderRepository _orderRepository;
        private readonly ReferenceConverter _referenceConverter;
        private readonly IRelationRepository _relationRepository;
        private readonly IRecommendationContext _recommendationContext;
        private readonly ICurrentMarket _currentMarket;
        private readonly IRequestTrackingDataService _requestTrackingDataService;
        private readonly ICartManager _cartManager;
        private const string CategorySeparator = ">";

        /// <summary>
        /// Initializes a new instance of the <see cref="T:EPiServer.Tracking.Commerce.TrackingDataFactory" /> class.
        /// </summary>
        [Obsolete("This constructor is no longer used, use constructor without IShippingCalculator instead. Will remain at least until May 2019.")]
        public CustomTrackingDataFactory(
          ILineItemCalculator lineItemCalculator,
          IContentLoader contentLoader,
          IOrderGroupCalculator orderGroupCalculator,
          IShippingCalculator shippingCalculator,
          LanguageResolver languageResolver,
          IOrderRepository orderRepository,
          ReferenceConverter referenceConverter,
          IRelationRepository relationRepository,
          IRecommendationContext recommendationContext,
          ICurrentMarket currentMarket,
          IUserDataService userDataService,
          ICartManager cartManager)
          : this(lineItemCalculator, contentLoader, orderGroupCalculator, languageResolver, orderRepository, referenceConverter, relationRepository, recommendationContext, currentMarket, userDataService, cartManager)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="T:EPiServer.Tracking.Commerce.TrackingDataFactory" /> class.
        /// </summary>
        [Obsolete("This constructor is no longer used, use constructor with IRequestTrackingDataService instead. Will remain at least until July 2019.")]
        public CustomTrackingDataFactory(
          ILineItemCalculator lineItemCalculator,
          IContentLoader contentLoader,
          IOrderGroupCalculator orderGroupCalculator,
          LanguageResolver languageResolver,
          IOrderRepository orderRepository,
          ReferenceConverter referenceConverter,
          IRelationRepository relationRepository,
          IRecommendationContext recommendationContext,
          ICurrentMarket currentMarket,
          IUserDataService userDataService,
          ICartManager cartManager)
          : this(lineItemCalculator, contentLoader, orderGroupCalculator, languageResolver, orderRepository, referenceConverter, relationRepository, recommendationContext, currentMarket, ServiceLocator.Current.GetInstance<IRequestTrackingDataService>(), cartManager)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="T:EPiServer.Tracking.Commerce.TrackingDataFactory" /> class.
        /// </summary>
        public CustomTrackingDataFactory(
          ILineItemCalculator lineItemCalculator,
          IContentLoader contentLoader,
          IOrderGroupCalculator orderGroupCalculator,
          LanguageResolver languageResolver,
          IOrderRepository orderRepository,
          ReferenceConverter referenceConverter,
          IRelationRepository relationRepository,
          IRecommendationContext recommendationContext,
          ICurrentMarket currentMarket,
          IRequestTrackingDataService requestTrackingDataService,
          ICartManager cartManager) 
            : base (lineItemCalculator, contentLoader, orderGroupCalculator, languageResolver, orderRepository, referenceConverter, relationRepository, recommendationContext, currentMarket, requestTrackingDataService)
        {
            this._lineItemCalculator = lineItemCalculator;
            this._contentLoader = contentLoader;
            this._orderGroupCalculator = orderGroupCalculator;
            this._languageResolver = languageResolver;
            this._orderRepository = orderRepository;
            this._referenceConverter = referenceConverter;
            this._relationRepository = relationRepository;
            this._recommendationContext = recommendationContext;
            this._currentMarket = currentMarket;
            this._requestTrackingDataService = requestTrackingDataService;
            this._cartManager = cartManager;
        }

        public new CartTrackingData CreateCartTrackingData(HttpContextBase httpContext, string cartName)
        {
            return this.CreateCartTrackingData(httpContext, Enumerable.Empty<CartChangeData>(), cartName);
        }

        public new CartTrackingData CreateCartTrackingData(HttpContextBase httpContext, IEnumerable<CartChangeData> cartChanges, string cartName)
        {
            IOrderGroup currentCart = (IOrderGroup)this._cartManager.GetCart(cartName);

            if (currentCart == null)
                return (CartTrackingData)null;
            
            return new CartTrackingData((IList<CartItemData>)this.GetCartDataItems(currentCart)
                                        , cartChanges
                                        , currentCart.Currency.CurrencyCode
                                        , this._languageResolver.GetPreferredCulture().Name
                                        , this.GetRequestData(httpContext)
                                        , this.GetCommerceUserData(httpContext));
        }



        #region Private Methods

        private CommerceUserData GetCommerceUserData(HttpContextBase httpContext)
        {
            return this._requestTrackingDataService.GetUser(httpContext);
        }

        private RequestData GetRequestData(HttpContextBase httpContext)
        {
            return this._requestTrackingDataService.GetRequestData(httpContext);
        }

        private List<CartItemData> GetCartDataItems(IOrderGroup orderGroup)
        {
            List<CartItemData> cartItemDataList = new List<CartItemData>();
            Mediachase.Commerce.Currency currency = orderGroup.Currency;
            foreach (ILineItem allLineItem in orderGroup.GetAllLineItems())
            {
                Decimal price = currency.Round(this._lineItemCalculator.GetDiscountedPrice(allLineItem, orderGroup.Currency).Divide(allLineItem.Quantity).Amount);
                string productCode = this.GetProductCode(allLineItem.Code);
                cartItemDataList.Add(new CartItemData(productCode, allLineItem.Code == productCode ? (string)null : allLineItem.Code, this.RoundQuantity(allLineItem.Quantity), price));
            }
            return cartItemDataList;
        }

        internal string GetProductCode(string variantCode)
        {
            return this._referenceConverter.GetCode(this.GetRootProduct(this._referenceConverter.GetContentLink(variantCode))) ?? variantCode;
        }

        private ContentReference GetRootProduct(ContentReference targetReference)
        {
            ProductVariation productVariation = this._relationRepository.GetParents<ProductVariation>(targetReference).FirstOrDefault<ProductVariation>();
            if (productVariation == null)
                return targetReference;
            return this.GetRootProduct(productVariation.Parent);
        }

        private int RoundQuantity(Decimal quantity)
        {
            int num = (int)Decimal.Round(quantity);
            if (num != 0)
                return num;
            return 1;
        }

        #endregion
    }
}