/// <summary> /// Instantiates a basket /// </summary> /// <param name="merchelloContext">The merchello context</param> /// <param name="customer">The customer associated with the basket</param> /// <returns>The <see cref="IBasket"/></returns> internal static IBasket GetBasket(IMerchelloContext merchelloContext, ICustomerBase customer) { Mandate.ParameterNotNull(merchelloContext, "merchelloContext"); Mandate.ParameterNotNull(customer, "customer"); var cacheKey = MakeCacheKey(customer); var basket = (IBasket)merchelloContext.Cache.RuntimeCache.GetCacheItem(cacheKey); if (basket != null) { return(basket); } var customerItemCache = merchelloContext.Services.ItemCacheService.GetItemCacheWithKey(customer, ItemCacheType.Basket); basket = new Basket(customerItemCache, customer); if (basket.Validate()) { merchelloContext.Cache.RuntimeCache.GetCacheItem(cacheKey, () => basket); } return(basket); }
/// <summary> /// Creates an anonymous customer /// </summary> private void CreateAnonymousCustomer() { var customer = _customerService.CreateAnonymousCustomerWithKey(); CurrentCustomer = customer; CacheCustomer(customer); }
public void Init() { _destination = new Address() { Name = "Mindfly Web Design Studio", Address1 = "114 W. Magnolia St. Suite 504", Locality = "Bellingham", Region = "WA", PostalCode = "98225", CountryCode = "US" }; PreTestDataWorker.DeleteAllItemCaches(); PreTestDataWorker.DeleteAllInvoices(); _customer = PreTestDataWorker.MakeExistingAnonymousCustomer(); _basket = Basket.GetBasket(MerchelloContext, _customer); for (var i = 0; i < ProductCount; i++) { _basket.AddItem(PreTestDataWorker.MakeExistingProduct(true, WeightPerProduct, PricePerProduct)); } Basket.Save(MerchelloContext, _basket); _shipCountry = ShipCountryService.GetShipCountryByCountryCode(Catalog.Key, "US"); }
/// <summary> /// Gets the checkout <see cref="IItemCache"/> for the <see cref="ICustomerBase"/> /// </summary> /// <param name="merchelloContext"> /// The <see cref="IMerchelloContext"/> /// </param> /// <param name="customer"> /// The customer associated with the checkout /// </param> /// <param name="versionKey"> /// The version key for this <see cref="SalePreparationBase"/> /// </param> /// <returns> /// The <see cref="IItemCache"/> associated with the customer checkout /// </returns> protected static IItemCache GetItemCache(IMerchelloContext merchelloContext, ICustomerBase customer, Guid versionKey) { var runtimeCache = merchelloContext.Cache.RuntimeCache; var cacheKey = MakeCacheKey(customer, versionKey); var itemCache = runtimeCache.GetCacheItem(cacheKey) as IItemCache; if (itemCache != null) { return(itemCache); } itemCache = merchelloContext.Services.ItemCacheService.GetItemCacheWithKey(customer, ItemCacheType.Checkout, versionKey); // this is probably an invalid version of the checkout if (!itemCache.VersionKey.Equals(versionKey)) { var oldCacheKey = MakeCacheKey(customer, itemCache.VersionKey); runtimeCache.ClearCacheItem(oldCacheKey); Reset(merchelloContext, customer); // delete the old version merchelloContext.Services.ItemCacheService.Delete(itemCache); return(GetItemCache(merchelloContext, customer, versionKey)); } runtimeCache.InsertCacheItem(cacheKey, () => itemCache); return(itemCache); }
/// <summary> /// Tries to apply the discount line item reward /// </summary> /// <param name="validate"> /// The <see cref="ILineItemContainer"/> to validate against /// </param> /// <param name="customer"> /// The customer. /// </param> /// <returns> /// The <see cref="Attempt{ILinetItem}"/>. /// </returns> public override Attempt <ILineItem> TryAward(ILineItemContainer validate, ICustomerBase customer) { var shippingLineItems = validate.ShippingLineItems(); var audits = shippingLineItems.Select(item => new CouponRewardAdjustmentAudit() { RelatesToSku = item.Sku, Log = new[] { new DataModifierLog() { PropertyName = "Price", OriginalValue = item.Price, ModifiedValue = 0M } } }).ToList(); // Get the item template var discountLineItem = CreateTemplateDiscountLineItem(audits); var discount = validate.ShippingLineItems().Sum(x => x.TotalPrice); discountLineItem.Price = discount; return(Attempt <ILineItem> .Succeed(discountLineItem)); }
/// <summary> /// Tries to apply the discount line item reward /// </summary> /// <param name="validate"> /// The <see cref="ILineItemContainer"/> to validate against /// </param> /// <param name="customer"> /// The customer. /// </param> /// <returns> /// The <see cref="Attempt{ILinetItem}"/>. /// </returns> public override Attempt<ILineItem> TryAward(ILineItemContainer validate, ICustomerBase customer) { if (!IsConfigured) return Attempt<ILineItem>.Fail(new OfferRedemptionException("The coupon reward is not configured.")); if (MerchelloContext.Current == null) return Attempt<ILineItem>.Fail(new OfferRedemptionException("The MerchelloContext was null")); // apply to the entire collection excluding previously added discounts var qualifying = Extensions.CreateNewItemCacheLineItemContainer(validate.Items.Where(x => x.LineItemType != LineItemType.Discount)); var visitor = new CouponDiscountLineItemRewardVisitor(Amount, AdjustmentType); qualifying.Items.Accept(visitor); var qualifyingTotal = visitor.QualifyingTotal; var discount = this.AdjustmentType == Adjustment.Flat ? this.Amount > qualifyingTotal ? qualifyingTotal : this.Amount : qualifyingTotal * (this.Amount / 100); // Get the item template var discountLineItem = CreateTemplateDiscountLineItem(visitor.Audits); discountLineItem.ExtendedData.SetValue(Core.Constants.ExtendedDataKeys.CouponAdjustedProductPreTaxTotal, visitor.AdjustedProductPreTaxTotal.ToString(CultureInfo.InvariantCulture)); discountLineItem.ExtendedData.SetValue(Core.Constants.ExtendedDataKeys.CouponAdjustedProductTaxTotal, visitor.AdjustedTaxTotal.ToString(CultureInfo.InvariantCulture)); discountLineItem.Price = discount; return Attempt<ILineItem>.Succeed(discountLineItem); }
/// <summary> /// Validates the constraint against the <see cref="ILineItemContainer"/> /// </summary> /// <param name="value"> /// The value to object to which the constraint is to be applied. /// </param> /// <param name="customer"> /// The <see cref="ICustomerBase"/>. /// </param> /// <returns> /// The <see cref="Attempt{ILineItemContainer}"/> indicating whether or not the constraint can be enforced. /// </returns> public override Attempt<ILineItemContainer> TryApply(ILineItemContainer value, ICustomerBase customer) { var visitor = new MaximumQuantityConstraintVisitor(MaximumQuantity); value.Items.Accept(visitor); return this.Success(this.CreateNewLineContainer(visitor.ModifiedItems)); }
public Simulations(ILogger logger, IWarehouse warehouse, ICustomerBase customerBase, IShop shop) { this.logger = logger; Warehouse = warehouse; CustomerBase = customerBase; Shop = shop; }
/// <summary> /// Provides an assertion that the customer cookie is associated with the correct customer Umbraco member relation. /// </summary> /// <param name="customer"> /// The customer. /// </param> /// <remarks> /// http://issues.merchello.com/youtrack/issue/M-454 /// </remarks> private void EnsureIsLoggedInCustomer(ICustomerBase customer) { if (_cache.RequestCache.GetCacheItem(CacheKeys.EnsureIsLoggedInCustomerValidated(customer.Key)) != null) { return; } var memberId = _membershipHelper.GetCurrentMemberId(); var dataValue = ContextData.Values.FirstOrDefault(x => x.Key == UmbracoMemberIdDataKey); // If the dataValues do not contain the umbraco member id reinitialize if (!string.IsNullOrEmpty(dataValue.Value)) { // Assert are equal if (!dataValue.Value.Equals(memberId.ToString(CultureInfo.InvariantCulture))) { this.Reinitialize(customer); } return; } if (dataValue.Value != memberId.ToString(CultureInfo.InvariantCulture)) { this.Reinitialize(customer); } }
/// <summary> /// Tries to apply the discount line item reward /// </summary> /// <param name="validate"> /// The <see cref="ILineItemContainer"/> to validate against /// </param> /// <param name="customer"> /// The customer. /// </param> /// <returns> /// The <see cref="Attempt{ILinetItem}"/>. /// </returns> public override Attempt<ILineItem> TryAward(ILineItemContainer validate, ICustomerBase customer) { var shippingLineItems = validate.ShippingLineItems(); var audits = shippingLineItems.Select(item => new CouponRewardAdjustmentAudit() { RelatesToSku = item.Sku, Log = new[] { new DataModifierLog() { PropertyName = "Price", OriginalValue = item.Price, ModifiedValue = 0M } } }).ToList(); // Get the item template var discountLineItem = CreateTemplateDiscountLineItem(audits); var discount = validate.ShippingLineItems().Sum(x => x.TotalPrice); discountLineItem.Price = discount; return Attempt<ILineItem>.Succeed(discountLineItem); }
/// <summary> /// The caches the customer. /// </summary> /// <param name="customer"> /// The customer. /// </param> private void CacheCustomer(ICustomerBase customer) { // set/reset the cookie var cookie = new HttpCookie(CustomerCookieName) { Value = this.ContextData.ToJson() }; // Ensure a session cookie for Anonymous customers if (customer.IsAnonymous) { if (_anonCookieExpireDays <= 0) { cookie.Expires = DateTime.MinValue; } else { var expires = DateTime.Now.AddDays(_anonCookieExpireDays); cookie.Expires = expires; } } this._umbracoContext.HttpContext.Response.Cookies.Add(cookie); this._cache.RequestCache.GetCacheItem(CustomerCookieName, () => this.ContextData); this._cache.RuntimeCache.GetCacheItem(CacheKeys.CustomerCacheKey(customer.Key), () => customer, TimeSpan.FromMinutes(20), true); }
/// <summary> /// Updates the context data. /// </summary> /// <param name="converted"> /// The converted. /// </param> /// <param name="ctxValues"> /// The context values. /// </param> private static void UpdateContextData(ICustomerBase converted, IEnumerable <KeyValuePair <string, string> > ctxValues) { foreach (var value in ctxValues) { converted.ExtendedData.SetValue(value.Key, value.Value); } }
public Buyer(ILogger logger, ICustomerBase customerBase, IWarehouse warehouse, IShop shop) { this.logger = logger; CustomerBase = customerBase; Warehouse = warehouse; Shop = shop; }
/// <summary> /// Creates a basket for a consumer with a given type /// </summary> /// <param name="customer"> /// The customer. /// </param> /// <param name="itemCacheType"> /// The item Cache Type. /// </param> /// <param name="versionKey"> /// The version Key. /// </param> /// <returns> /// The <see cref="IItemCache"/>. /// </returns> public IItemCache GetItemCacheWithKey(ICustomerBase customer, ItemCacheType itemCacheType, Guid versionKey) { Mandate.ParameterCondition(Guid.Empty != versionKey, "versionKey"); // determine if the consumer already has a item cache of this type, if so return it. var itemCache = GetItemCacheByCustomer(customer, itemCacheType); if (itemCache != null) return itemCache; itemCache = new ItemCache(customer.Key, itemCacheType) { VersionKey = versionKey }; if (Creating.IsRaisedEventCancelled(new Events.NewEventArgs<IItemCache>(itemCache), this)) { // registry.WasCancelled = true; return itemCache; } itemCache.EntityKey = customer.Key; using (new WriteLock(Locker)) { var uow = _uowProvider.GetUnitOfWork(); using (var repository = _repositoryFactory.CreateItemCacheRepository(uow)) { repository.AddOrUpdate(itemCache); uow.Commit(); } } Created.RaiseEvent(new Events.NewEventArgs<IItemCache>(itemCache), this); return itemCache; }
/// <summary> /// Instantiates a wish list /// </summary> /// <param name="merchelloContext">The merchello context</param> /// <param name="customer">The customer associated with the wish list</param> /// <returns>The <see cref="IWishList"/></returns> internal static IWishList GetWishList(IMerchelloContext merchelloContext, ICustomerBase customer) { Mandate.ParameterNotNull(merchelloContext, "merchelloContext"); Mandate.ParameterNotNull(customer, "customer"); var cacheKey = MakeCacheKey(customer); var wishlist = (IWishList)merchelloContext.Cache.RuntimeCache.GetCacheItem(cacheKey); if (wishlist != null && wishlist.Validate()) { return(wishlist); } var customerItemCache = merchelloContext.Services.ItemCacheService.GetItemCacheWithKey(customer, ItemCacheType.Wishlist); wishlist = new WishList(customerItemCache, customer); if (wishlist.Validate()) { merchelloContext.Cache.RuntimeCache.GetCacheItem(cacheKey, () => wishlist, TimeSpan.FromHours(2)); } return(wishlist); }
public void Init() { PreTestDataWorker.DeleteAllItemCaches(); _customer = PreTestDataWorker.MakeExistingAnonymousCustomer(); _basket = Basket.GetBasket(MerchelloContext.Current, _customer); }
/// <summary> /// Inserts an address record in the merchBasket table and returns an <see cref="IItemCache"/> object representation /// </summary> public IItemCache MakeExistingItemCache(ICustomerBase customer, ItemCacheType itemCacheType) { var itemCache = MockCustomerItemCacheDataMaker.ConsumerItemCacheForInserting(customer, itemCacheType); ItemCacheService.Save(itemCache); return(itemCache); }
/// <summary> /// Try to apply the award /// </summary> /// <param name="validatedAgainst"> /// The validated against. /// </param> /// <param name="customer"> /// The customer. /// </param> /// <returns> /// The <see cref="Attempt"/>. /// </returns> public Attempt <object> TryAward(object validatedAgainst, ICustomerBase customer) { if (!this.IsInitialized) { return(Attempt <object> .Fail(new OfferRedemptionException("Offer processor not initialized."))); } try { var reward = _reward as OfferRewardComponentBase <TConstraint, TAward>; var converted = validatedAgainst.TryConvertTo <TConstraint>(); if (converted.Success) { if (reward == null) { return(Attempt <object> .Fail(new NullReferenceException("Converted reward was null"))); } var rewardAttempt = reward.TryAward(converted.Result, customer); return(!rewardAttempt.Success ? Attempt <object> .Fail(rewardAttempt.Result, rewardAttempt.Exception) : Attempt <object> .Succeed(rewardAttempt.Result)); } LogHelper.Error(typeof(OfferProcessorBase <TConstraint, TAward>), "Failed to convert validation object", converted.Exception); throw converted.Exception; } catch (Exception ex) { LogHelper.Error(typeof(OfferProcessorBase <TConstraint, TAward>), "Failed to convert reward type", ex); throw; } }
/// <summary> /// Applies the constraints /// </summary> /// <param name="validatedAgainst"> /// The constrain by. /// </param> /// <param name="customer"> /// The customer. /// </param> /// <returns> /// The <see cref="Attempt"/>. /// </returns> public Attempt <object> TryApplyConstraints(object validatedAgainst, ICustomerBase customer) { if (!this.IsInitialized) { return(Attempt <object> .Fail(new OfferRedemptionException("Offer processor not initialized."))); } var convert = validatedAgainst.TryConvertTo <TConstraint>(); if (!convert.Success) { var invalid = new InvalidOperationException( "validatedAgainst parameter could not be converted to type " + typeof(TConstraint).FullName); return(Attempt <object> .Fail(invalid)); } if (TaskHandlers.Any()) { TaskHandlers.Clear(); } this.BuildConstraintChain(this._constraints.Select(x => this.ConvertConstraintToTask(x, customer))); var attempt = TaskHandlers.Any() ? TaskHandlers.First().Execute(convert.Result) : Attempt <TConstraint> .Succeed(convert.Result); // there were no constraints // convert bask to an object return(attempt.Success ? Attempt <object> .Succeed(attempt.Result) : Attempt <object> .Fail(attempt.Result, attempt.Exception)); }
public virtual void FixtureSetup() { // Sets Umbraco SqlSytax and ensure database is setup DbPreTestDataWorker = new DbPreTestDataWorker(); DbPreTestDataWorker.ValidateDatabaseSetup(); DbPreTestDataWorker.DeleteAllAnonymousCustomers(); // Merchello CoreBootStrap var bootManager = new WebBootManager(); bootManager.Initialize(); if(MerchelloContext.Current == null) Assert.Ignore("MerchelloContext.Current is null"); CurrentCustomer = DbPreTestDataWorker.MakeExistingAnonymousCustomer(); // Product saves ProductService.Created += ProductServiceCreated; ProductService.Saved += ProductServiceSaved; ProductService.Deleted += ProductServiceDeleted; ProductVariantService.Created += ProductVariantServiceCreated; ProductVariantService.Saved += ProductVariantServiceSaved; ProductVariantService.Deleted += ProductVariantServiceDeleted; // BasketCheckout // ItemCacheService.Saved += BasketItemCacheSaved; }
private void EnsureIsLoggedInCustomer(ICustomerBase customer, string membershipId) { if (this._cache.RequestCache.GetCacheItem(CacheKeys.EnsureIsLoggedInCustomerValidated(customer.Key)) != null) { return; } var dataValue = this.ContextData.Values.FirstOrDefault(x => x.Key == UmbracoMemberIdDataKey); // If the dataValues do not contain the umbraco member id reinitialize if (!string.IsNullOrEmpty(dataValue.Value)) { // Assert are equal if (!dataValue.Value.Equals(membershipId)) { this.Reinitialize(customer); } return; } if (dataValue.Value != membershipId) { this.Reinitialize(customer); } }
public static IItemCache ConsumerItemCacheForInserting(ICustomerBase customer, ItemCacheType itemCacheType) { return(new ItemCache(customer.EntityKey, itemCacheType) { EntityKey = customer.EntityKey }); }
public static IItemCache ConsumerItemCacheForInserting(ICustomerBase customer, ItemCacheType itemCacheType) { return new ItemCache(customer.EntityKey, itemCacheType) { EntityKey = customer.EntityKey }; }
public OfferConstraintChainTask(OfferConstraintComponentBase <T> component, ICustomerBase customer) { Mandate.ParameterNotNull(component, "component"); Mandate.ParameterNotNull(customer, "customer"); _component = component; _customer = customer; }
/// <summary> /// Overrides the creation of the <see cref="ICustomerProfile"/>. /// </summary> /// <param name="model"> /// The <see cref="NewMemberModel"/>. /// </param> /// <param name="customer"> /// The <see cref="CustomerBase"/>. /// </param> /// <returns> /// The modified <see cref="NewMemberModel"/>. /// </returns> protected override TModel OnCreate(TModel model, ICustomerBase customer) { model.MemberTypeAlias = "merchelloCustomer"; model.PersistLogin = true; model.ViewData = new StoreViewData(); return(base.OnCreate(model, customer)); }
/// <summary> /// Initializes a new instance of the <see cref="CheckoutEventArgs{T}"/> class. /// </summary> /// <param name="customer"> /// The customer. /// </param> /// <param name="item"> /// The item. /// </param> public CheckoutEventArgs(ICustomerBase customer, T item) : base(item, true) { Mandate.ParameterNotNull(customer, "customer"); Mandate.ParameterNotNull(item, "item"); this.Customer = customer; }
/// <summary> /// Gets the Braintree server token. /// </summary> /// <param name="customer"> /// The current customer. /// </param> /// <returns> /// The Braintree server token /// </returns> protected string GetBraintreeToken(ICustomerBase customer) { var token = customer.IsAnonymous ? this._braintreeApiService.Customer.GenerateClientRequestToken() : this._braintreeApiService.Customer.GenerateClientRequestToken((ICustomer)customer); return(token); }
private string CreateQuery(ICustomerBase customer) { if (customer == null) { return(string.Empty); } var query = new StringBuilder(); if (customer.CustomerId > 0) { query.Append($"WHERE CustomerId={customer.CustomerId}"); } if (!string.IsNullOrEmpty(customer.FirstName)) { if (query.Length == 0) { query.Append("WHERE "); } else { query.Append(" AND "); } query.Append($"FirstName LIKE N'%{customer.FirstName}%'"); } if (!string.IsNullOrEmpty(customer.LastName)) { if (query.Length == 0) { query.Append("WHERE "); } else { query.Append(" AND "); } query.Append($"LastName LIKE N'%{customer.LastName}%'"); } if (!string.IsNullOrEmpty(customer.Email)) { if (query.Length == 0) { query.Append("WHERE "); } else { query.Append(" AND "); } query.Append($"Email LIKE '%{customer.Email}%'"); } return(query.ToString()); }
/// <summary> /// Returns a collection of item caches for the consumer /// </summary> /// <param name="customer"> /// The customer. /// </param> /// <returns> /// The <see cref="IEnumerable{IItemCache}"/>. /// </returns> public IEnumerable <IItemCache> GetItemCacheByCustomer(ICustomerBase customer) { using (var repository = RepositoryFactory.CreateItemCacheRepository(UowProvider.GetUnitOfWork())) { var query = Query <IItemCache> .Builder.Where(x => x.EntityKey == customer.Key); return(repository.GetByQuery(query)); } }
/// <summary> /// Returns the customer item cache of a given type. This method will not create an item cache if the cache does not exist. /// </summary> /// <param name="customer"> /// The customer. /// </param> /// <param name="itemCacheTfKey"> /// The item Cache type field Key. /// </param> /// <returns> /// The <see cref="IItemCache"/>. /// </returns> public IItemCache GetItemCacheByCustomer(ICustomerBase customer, Guid itemCacheTfKey) { using (var repository = RepositoryFactory.CreateItemCacheRepository(UowProvider.GetUnitOfWork())) { var query = Query <IItemCache> .Builder.Where(x => x.EntityKey == customer.Key && x.ItemCacheTfKey == itemCacheTfKey); return(repository.GetByQuery(query).FirstOrDefault()); } }
internal Basket(IItemCache itemCache, ICustomerBase customer) { Mandate.ParameterNotNull(itemCache, "ItemCache"); Mandate.ParameterCondition(itemCache.ItemCacheType == ItemCacheType.Basket, "itemCache"); Mandate.ParameterNotNull(customer, "customer"); _customer = customer; _itemCache = itemCache; }
public IEnumerable <IShipmentRateQuote> GetShippingMethods(BackofficeAddItemModel model) { _customer = MerchelloContext.Services.CustomerService.GetAnyByKey(new Guid(model.CustomerKey)); _backoffice = _customer.Backoffice(); var shipment = _backoffice.PackageBackoffice(model.ShippingAddress.ToAddress()).FirstOrDefault(); return(shipment.ShipmentRateQuotes()); }
/// <summary> /// Initializes a new instance of the <see cref="CustomerItemCacheBase"/> class. /// </summary> /// <param name="itemCache"> /// The item cache. /// </param> /// <param name="customer"> /// The customer. /// </param> protected CustomerItemCacheBase(IItemCache itemCache, ICustomerBase customer) { Mandate.ParameterNotNull(itemCache, "ItemCache"); Mandate.ParameterNotNull(customer, "customer"); _customer = customer; _itemCache = itemCache; EnableDataModifiers = true; this.Initialize(); }
/// <summary> /// Initializes the <see cref="MerchelloControllerBase"/> /// </summary> private void Initialize() { var customerContext = new CustomerContext(UmbracoContext); _currentCustomer = customerContext.CurrentCustomer; _home = new Lazy <IPublishedContent>(GetHomePage); _basket = _currentCustomer.Basket(); }
/// <summary> /// Initializes a new instance of the <see cref="BasketLineItemFactory"/> class. /// </summary> /// <param name="umbraco"> /// The umbraco. /// </param> /// <param name="currentCustomer"> /// The current Customer. /// </param> /// <param name="currency"> /// The currency. /// </param> public BasketLineItemFactory(UmbracoHelper umbraco, ICustomerBase currentCustomer, ICurrency currency) { Mandate.ParameterNotNull(umbraco, "umbraco"); Mandate.ParameterNotNull(currency, "currency"); Mandate.ParameterNotNull(currentCustomer, "currentCustomer"); this._umbraco = umbraco; this._currency = currency; this._currentCustomer = currentCustomer; }
/// <summary> /// Tries to apply the discount line item reward /// </summary> /// <param name="validate"> /// The <see cref="ILineItemContainer"/> to validate against /// </param> /// <param name="customer"> /// The customer. /// </param> /// <returns> /// The <see cref="Attempt{ILinetItem}"/>. /// </returns> public override Attempt<ILineItem> TryAward(ILineItemContainer validate, ICustomerBase customer) { // Get the item template var discountLineItem = CreateTemplateDiscountLineItem(); var discount = validate.ShippingLineItems().Sum(x => x.TotalPrice); discountLineItem.Price = discount; return Attempt<ILineItem>.Succeed(discountLineItem); }
/// <summary> /// The try apply. /// </summary> /// <param name="value"> /// The value. /// </param> /// <param name="customer"> /// The customer. /// </param> /// <returns> /// The <see cref="Attempt"/>. /// </returns> public override Attempt<ILineItemContainer> TryApply(ILineItemContainer value, ICustomerBase customer) { if (MerchelloContext.Current != null) { if (!MerchelloContext.Current.Gateways.Taxation.ProductPricingEnabled) return this.Success(value); var vistor = new ExcludeTaxesInProductPricesVisitor(); value.Items.Accept(vistor); return this.Success(value); } return Attempt<ILineItemContainer>.Fail(new NullReferenceException("MerchelloContext was null")); }
/// <summary> /// Initializes a new instance of the <see cref="SalePreparationBase"/> class. /// </summary> /// <param name="merchelloContext"> /// The merchello context. /// </param> /// <param name="itemCache"> /// The item cache. /// </param> /// <param name="customer"> /// The customer. /// </param> internal SalePreparationBase(IMerchelloContext merchelloContext, IItemCache itemCache, ICustomerBase customer) { Mandate.ParameterNotNull(merchelloContext, "merchelloContext"); Mandate.ParameterNotNull(itemCache, "ItemCache"); Mandate.ParameterCondition(itemCache.ItemCacheType == ItemCacheType.Checkout, "itemCache"); Mandate.ParameterNotNull(customer, "customer"); _merchelloContext = merchelloContext; _customer = customer; _itemCache = itemCache; ApplyTaxesToInvoice = true; }
/// <summary> /// The ensure customer creation and convert basket. /// </summary> /// <param name="customer"> /// The customer. /// </param> protected override void EnsureCustomerCreationAndConvertBasket(ICustomerBase customer) { if (!customer.IsAnonymous) return; var memberId = Convert.ToInt32(this.MembershipProviderKey(customer.Key)); var member = _memberService.GetById(memberId); if (MerchelloConfiguration.Current.CustomerMemberTypes.Any(x => x == member.ContentTypeAlias)) { base.EnsureCustomerCreationAndConvertBasket(customer); } }
private void CacheCustomer(ICustomerBase customer) { // set/reset the cookie // TODO decide how we want to deal with cookie persistence options var cookie = new HttpCookie(ConsumerCookieKey) { Value = EncryptionHelper.Encrypt(customer.EntityKey.ToString()) }; _umbracoContext.HttpContext.Response.Cookies.Add(cookie); _cache.RequestCache.GetCacheItem(ConsumerCookieKey, () => customer.EntityKey); _cache.RuntimeCache.GetCacheItem(CacheKeys.CostumerCacheKey(customer.EntityKey), () => customer, TimeSpan.FromMinutes(5), true); }
/// <summary> /// Initializes a new instance of the <see cref="CheckoutContext"/> class. /// </summary> /// <param name="customer"> /// The <see cref="ICustomerBase"/> associated with this checkout. /// </param> /// <param name="itemCache"> /// The temporary <see cref="IItemCache"/> of the basket <see cref="IItemCache"/> to be used in the /// checkout process. /// </param> /// <param name="merchelloContext"> /// The <see cref="IMerchelloContext"/>. /// </param> /// <param name="settings"> /// The version change settings. /// </param> public CheckoutContext(ICustomerBase customer, IItemCache itemCache, IMerchelloContext merchelloContext, ICheckoutContextSettings settings) { Mandate.ParameterNotNull(customer, "customer"); Mandate.ParameterNotNull(itemCache, "itemCache"); Mandate.ParameterNotNull(merchelloContext, "merchelloContext"); Mandate.ParameterNotNull(settings, "settings"); this.MerchelloContext = merchelloContext; this.ItemCache = itemCache; this.Customer = customer; this.Cache = merchelloContext.Cache.RuntimeCache; this.ApplyTaxesToInvoice = true; this.Settings = settings; this.RaiseCustomerEvents = false; }
protected MerchelloSurfaceContoller(IMerchelloContext merchelloContext) { if (merchelloContext == null) { var ex = new ArgumentNullException("merchelloContext"); LogHelper.Error<MerchelloSurfaceContoller>("The MerchelloContext was null upon instantiating the CartController.", ex); throw ex; } _merchelloContext = merchelloContext; var customerContext = new CustomerContext(UmbracoContext); // UmbracoContext is from SurfaceController _currentCustomer = customerContext.CurrentCustomer; _basket = _currentCustomer.Basket(); }
/// <summary> /// Validates the constraint against the <see cref="ILineItemContainer"/> /// </summary> /// <param name="value"> /// The value to object to which the constraint is to be applied. /// </param> /// <param name="customer"> /// The <see cref="ICustomerBase"/>. /// </param> /// <returns> /// The <see cref="Attempt{ILineItemContainer}"/> indicating whether or not the constraint can be enforced. /// </returns> public override Attempt<ILineItemContainer> TryApply(ILineItemContainer value, ICustomerBase customer) { if (customer.IsAnonymous) return Attempt<ILineItemContainer>.Fail(new OfferRedemptionException("Cannot be applied by anonymous customers.")); if (MerchelloContext.Current != null) { var offerRedeemedService = ((ServiceContext)MerchelloContext.Current.Services).OfferRedeemedService; var offerSettingsKey = this.OfferComponentDefinition.OfferSettingsKey; var remptions = offerRedeemedService.GetByOfferSettingsKeyAndCustomerKey(offerSettingsKey, customer.Key); return remptions.Any() ? this.Fail(value, "Customer has already redeemed this offer.") : this.Success(value); } return Attempt<ILineItemContainer>.Fail(new NullReferenceException("MerchelloContext was null")); }
/// <summary> /// Validates the constraint against the <see cref="ILineItemContainer"/> /// </summary> /// <param name="value"> /// The value to object to which the constraint is to be applied. /// </param> /// <param name="customer"> /// The <see cref="ICustomerBase"/>. /// </param> /// <returns> /// The <see cref="Attempt{ILineItemContainer}"/> indicating whether or not the constraint can be enforced. /// </returns> public override Attempt<ILineItemContainer> TryApply(ILineItemContainer value, ICustomerBase customer) { if (MaximumRedemptions == 0) return Attempt<ILineItemContainer>.Succeed(value); if (MerchelloContext.Current != null) { var offerRedeemedService = ((ServiceContext)MerchelloContext.Current.Services).OfferRedeemedService; var offerSettingsKey = this.OfferComponentDefinition.OfferSettingsKey; var remptionCount = offerRedeemedService.GetOfferRedeemedCount(offerSettingsKey); return remptionCount >= MaximumRedemptions ? this.Fail(value, "Redemption count would exceed the maximum number of allowed") : this.Success(value); } return this.Fail(value, "MerchelloContext was null"); }
public virtual void FixtureSetup() { //AutoMapperMappings.CreateMappings(); // Umbraco Application var applicationMock = new Mock<UmbracoApplication>(); // Sets Umbraco SqlSytax and ensure database is setup DbPreTestDataWorker = new DbPreTestDataWorker(); DbPreTestDataWorker.ValidateDatabaseSetup(); DbPreTestDataWorker.DeleteAllAnonymousCustomers(); // Merchello CoreBootStrap var bootManager = new WebBootManager(DbPreTestDataWorker.TestLogger); bootManager.Initialize(); if(MerchelloContext.Current == null) Assert.Ignore("MerchelloContext.Current is null"); CurrentCustomer = DbPreTestDataWorker.MakeExistingAnonymousCustomer(); // Product saves ProductService.Created += ProductServiceCreated; ProductService.Saved += ProductServiceSaved; ProductService.Deleted += ProductServiceDeleted; ProductVariantService.Created += ProductVariantServiceCreated; ProductVariantService.Saved += ProductVariantServiceSaved; ProductVariantService.Deleted += ProductVariantServiceDeleted; // BasketCheckout // ItemCacheService.Saved += BasketItemCacheSaved; SalePreparationBase.Finalizing += SalePreparationBaseOnFinalizing; EntityCollectionService.Created += EntityCollectionServiceOnCreated; EntityCollectionService.Deleted += EntityCollectionServiceOnDeleted; }
/// <summary> /// The ensure customer and convert basket. /// </summary> /// <param name="customer"> /// The customer. /// </param> protected virtual void EnsureCustomerCreationAndConvertBasket(ICustomerBase customer) { ConvertBasket(customer, this.GetMembershipProviderKey(), this.GetMembershipProviderUserName()); }
public void Init() { PreTestDataWorker.DeleteAllProducts(); PreTestDataWorker.DeleteAllItemCaches(); _customer = PreTestDataWorker.MakeExistingAnonymousCustomer(); _basket = Basket.GetBasket(MerchelloContext.Current, _customer); for(var i = 0; i < ProductCount; i++) _basket.AddItem(PreTestDataWorker.MakeExistingProduct()); _basket.AddItem(PreTestDataWorker.MakeExistingProduct(false)); Basket.Save(MerchelloContext.Current, _basket); }
private void EnsureIsLoggedInCustomer(ICustomerBase customer, string membershipId) { if (this._cache.RequestCache.GetCacheItem(CacheKeys.EnsureIsLoggedInCustomerValidated(customer.Key)) != null) return; var dataValue = this.ContextData.Values.FirstOrDefault(x => x.Key == UmbracoMemberIdDataKey); // If the dataValues do not contain the umbraco member id reinitialize if (!string.IsNullOrEmpty(dataValue.Value)) { // Assert are equal if (!dataValue.Value.Equals(membershipId)) this.Reinitialize(customer); return; } if (dataValue.Value != membershipId) this.Reinitialize(customer); }
/// <summary> /// Purges persisted checkout information /// </summary> /// <param name="merchelloContext"> /// The merchello Context. /// </param> /// <param name="customer"> /// The customer. /// </param> private static void Reset(IMerchelloContext merchelloContext, ICustomerBase customer) { customer.ExtendedData.RemoveValue(Core.Constants.ExtendedDataKeys.ShippingDestinationAddress); customer.ExtendedData.RemoveValue(Core.Constants.ExtendedDataKeys.BillingAddress); SaveCustomer(merchelloContext, customer); }
/// <summary> /// Saves the current customer /// </summary> /// <param name="merchelloContext"> /// The merchello Context. /// </param> /// <param name="customer"> /// The customer. /// </param> private static void SaveCustomer(IMerchelloContext merchelloContext, ICustomerBase customer) { if (typeof(AnonymousCustomer) == customer.GetType()) { merchelloContext.Services.CustomerService.Save(customer as AnonymousCustomer); } else { ((CustomerService)merchelloContext.Services.CustomerService).Save(customer as Customer); } }
/// <summary> /// Gets the checkout <see cref="IItemCache"/> for the <see cref="ICustomerBase"/> /// </summary> /// <param name="merchelloContext"> /// The <see cref="IMerchelloContext"/> /// </param> /// <param name="customer"> /// The customer associated with the checkout /// </param> /// <param name="versionKey"> /// The version key for this <see cref="SalePreparationBase"/> /// </param> /// <returns> /// The <see cref="IItemCache"/> associated with the customer checkout /// </returns> protected static IItemCache GetItemCache(IMerchelloContext merchelloContext, ICustomerBase customer, Guid versionKey) { var runtimeCache = merchelloContext.Cache.RuntimeCache; var cacheKey = MakeCacheKey(customer, versionKey); var itemCache = runtimeCache.GetCacheItem(cacheKey) as IItemCache; if (itemCache != null) return itemCache; itemCache = merchelloContext.Services.ItemCacheService.GetItemCacheWithKey(customer, ItemCacheType.Checkout, versionKey); // this is probably an invalid version of the checkout if (!itemCache.VersionKey.Equals(versionKey)) { var oldCacheKey = MakeCacheKey(customer, itemCache.VersionKey); runtimeCache.ClearCacheItem(oldCacheKey); Reset(merchelloContext, customer); // delete the old version merchelloContext.Services.ItemCacheService.Delete(itemCache); return GetItemCache(merchelloContext, customer, versionKey); } runtimeCache.InsertCacheItem(cacheKey, () => itemCache); return itemCache; }
/// <summary> /// Generates a unique cache key for runtime caching of the <see cref="SalePreparationBase"/> /// </summary> /// <param name="customer">The <see cref="ICustomerBase"/> for which to generate the cache key</param> /// <param name="versionKey">The version key</param> /// <returns>The unique CacheKey string</returns> /// <remarks> /// /// CacheKey is assumed to be unique per customer and globally for CheckoutBase. Therefore this will NOT be unique if /// to different checkouts are happening for the same customer at the same time - we consider that an extreme edge case. /// /// </remarks> private static string MakeCacheKey(ICustomerBase customer, Guid versionKey) { var itemCacheTfKey = EnumTypeFieldConverter.ItemItemCache.Checkout.TypeKey; return Cache.CacheKeys.ItemCacheCacheKey(customer.Key, itemCacheTfKey, versionKey); }
/// <summary> /// Converts an anonymous customer's basket to a customer basket /// </summary> /// <param name="customer"> /// The anonymous customer - <see cref="ICustomerBase"/>. /// </param> /// <param name="membershipId"> /// The Membership Providers . /// </param> /// <param name="customerLoginName"> /// The customer login name. /// </param> protected void ConvertBasket(ICustomerBase customer, string membershipId, string customerLoginName) { var anonymousBasket = Basket.GetBasket(this._merchelloContext, customer); customer = this.CustomerService.GetByLoginName(customerLoginName) ?? this.CustomerService.CreateCustomerWithKey(customerLoginName); this.ContextData.Key = customer.Key; this.ContextData.Values.Add(new KeyValuePair<string, string>(UmbracoMemberIdDataKey, membershipId)); var customerBasket = Basket.GetBasket(this._merchelloContext, customer); //// convert the customer basket ConvertBasket(anonymousBasket, customerBasket); this.CacheCustomer(customer); this.CurrentCustomer = customer; }
/// <summary> /// The caches the customer. /// </summary> /// <param name="customer"> /// The customer. /// </param> private void CacheCustomer(ICustomerBase customer) { // set/reset the cookie // TODO decide how we want to deal with cookie persistence options var cookie = new HttpCookie(CustomerCookieName) { Value = this.ContextData.ToJson() }; // Ensure a session cookie for Anonymous customers // TODO - on persisted authenticcation, we need to synch the cookie expiration if (customer.IsAnonymous) cookie.Expires = DateTime.MinValue; this._umbracoContext.HttpContext.Response.Cookies.Add(cookie); this._cache.RequestCache.GetCacheItem(CustomerCookieName, () => this.ContextData); this._cache.RuntimeCache.GetCacheItem(CacheKeys.CustomerCacheKey(customer.Key), () => customer, TimeSpan.FromMinutes(5), true); }
/// <summary> /// Validates the constraint against the <see cref="ILineItemContainer"/> /// </summary> /// <param name="value"> /// The value to object to which the constraint is to be applied. /// </param> /// <param name="customer"> /// The <see cref="ICustomerBase"/>. /// </param> /// <returns> /// The <see cref="Attempt{ILineItemContainer}"/> indicating whether or not the constraint can be enforced. /// </returns> public override Attempt<ILineItemContainer> TryApply(ILineItemContainer value, ICustomerBase customer) { return !value.ContainsAnyCoupons() ? this.Success(value) : this.Fail(value, "One or more coupons have already been added."); }
/// <summary> /// Reinitializes the customer context /// </summary> /// <param name="customer"> /// The <see cref="CustomerBase"/> /// </param> /// <remarks> /// Sometimes useful to clear the various caches used internally in the customer context /// </remarks> public virtual void Reinitialize(ICustomerBase customer) { // customer has logged out, so we need to go back to an anonymous customer var cookie = this._umbracoContext.HttpContext.Request.Cookies[CustomerCookieName]; if (cookie == null) { this.Initialize(); return; } cookie.Expires = DateTime.Now.AddDays(-1); this._cache.RequestCache.ClearCacheItem(CustomerCookieName); this._cache.RuntimeCache.ClearCacheItem(CacheKeys.CustomerCacheKey(customer.Key)); this.Initialize(); }
/// <summary> /// Validates the constraint against the <see cref="ILineItemContainer"/> /// </summary> /// <param name="value"> /// The value to object to which the constraint is to be applied. /// </param> /// <param name="customer"> /// The <see cref="ICustomerBase"/>. /// </param> /// <returns> /// The <see cref="Attempt{ILineItemContainer}"/> indicating whether or not the constraint can be enforced. /// </returns> public override Attempt<ILineItemContainer> TryApply(ILineItemContainer value, ICustomerBase customer) { return Attempt<ILineItemContainer>.Succeed(CreateNewLineContainer(value.Items.Where(x => x.LineItemType != LineItemType.Shipping))); }