Blog posts by David Ketnor2014-08-12T17:09:34.0000000Zhttps://world.optimizely.com/blogs/David-Ketnor/Optimizely WorldICurrentMarket Storage Providers<p>This is my first ever blog post, so be gentle ;)</p> <p>In this post we’re going to discuss how we can create a number of different storage provider’s for use with our ICurrentMarket implementation. The main objectives for this post will be to: </p> <ul> <li>Provide implementations for a number of different storage providers, including Session, Profile, Cookie </li> <li>Highlight how clean, well architected code will allow your implementation to serve numerous clients and provide more extensible solutions </li> </ul> <p>So without further ado, we’ll get started.</p> <h3>ICurrentMarket</h3> <p>The purpose of this interface is to return the market of the current request as detailed <a href="http://world.episerver.com/Documentation/Items/Developers-Guide/EPiServer-Commerce/75/Markets/Markets/">here</a>.</p> <p>Here is a typical implementation taken from the commerce demo site, which persists the users current market within their membership profile.</p> <pre style="width: 100%">namespace EPiServer.Commerce.Sample.Helpers
{
/// <summary>
/// Implementation of current market selection that stores information in user profile.
/// </summary>
public class MarketStorage : ICurrentMarket
{
private const string _marketIdKey = "MarketId";
private readonly IMarketService _marketService;
/// <summary>
/// Initializes a new instance of the <see cref="MarketStorage" /> class.
/// </summary>
public MarketStorage()
: this(ServiceLocation.ServiceLocator.Current.GetInstance<imarketservice>())
{ }
/// <summary>
/// Initializes a new instance of the <see cref="MarketStorage" /> class.
/// </summary>
/// <param name="marketService" />The market service.
public MarketStorage(IMarketService marketService)
{
_marketService = marketService;
}
/// <summary>
/// Gets the <see cref="IMarket" /> selected in the current user profile, if the value is
/// set and the indicated market is valid; ; otherwise, gets the default <see cref="IMarket" />.
/// </summary>
/// <returns>The current <see cref="IMarket" />.</returns>
public IMarket GetCurrentMarket()
{
var profileStorage = GetProfileStorage();
var profileMarketId = profileStorage == null ? null : profileStorage[_marketIdKey] as string;
var marketId = string.IsNullOrEmpty(profileMarketId) ? MarketId.Default : new MarketId(profileMarketId);
var market = _marketService.GetMarket(marketId);
if (market == null && marketId != MarketId.Default)
{
market = _marketService.GetMarket(MarketId.Default);
}
UpdateProfile(market);
return market;
}
/// <summary>
/// Sets the current market, if <paramref name="marketId" /> represents a valid market;
/// otherwise, performs no action.
/// </summary>
/// <param name="marketId" />The market id.
/// <remarks>This will also set the current currency for the ECF context.</remarks>
public void SetCurrentMarket(MarketId marketId)
{
var market = _marketService.GetMarket(marketId);
if (market != null)
{
UpdateProfile(market);
SiteContext.Current.Currency = market.DefaultCurrency;
Globalization.ContentLanguage.PreferredCulture = market.DefaultLanguage;
}
}
private void UpdateProfile(IMarket market)
{
var profileStorage = GetProfileStorage();
if (profileStorage != null)
{
var originalMarketId = profileStorage[_marketIdKey] as string;
var currentMarketId = market == null || market.MarketId == MarketId.Default ? string.Empty : market.MarketId.Value;
if (!string.Equals(originalMarketId, currentMarketId, StringComparison.Ordinal))
{
profileStorage[_marketIdKey] = currentMarketId;
profileStorage.Save();
}
}
}
private ProfileBase GetProfileStorage()
{
var httpContext = HttpContext.Current;
return httpContext == null ? null : httpContext.Profile;
}
}
}</imarketservice></pre>
<p>This works well, but includes the underlying persistence within the actual implementation of ICurrentMarket. If we had further clients who had different persistence requirements, we need to implement ICurrentMarket again which would result in repeated ICurrentMarket implementations (<a href="http://en.wikipedia.org/wiki/Don't_repeat_yourself">DRY</a>).</p>
<p>If we abstracted the Current Market storage implementation out of ICurrentMarket we’d be in a better place.</p>
<p>Enter ICurrentMarketStorageProvider</p>
<h3>ICurrentMarketStorageProvider</h3>
<p>The purpose of this interface is to and store and retrieve the current market. </p>
<pre style="width: 100%">public interface ICurrentMarketStorageProvider
{
string MarketIdKey { get; }
string Get();
void Set(string value);
}</pre>
<p>This is a pretty simple implementation, so how does it change our implementation of ICurrentMarket?</p>
<pre style="width: 100%">/// <summary>
/// Implementation of current market selection.
/// </summary>
public class SiteCurrentMarket : ICurrentMarket
{
private readonly IMarketService marketService;
private readonly ICurrentMarketStorageProvider storageProvider;
/// <summary>
/// Initializes a new instance of the <see cref="SiteCurrentMarket" /> class.
/// </summary>
/// <param name="marketService" />The market service.
/// <param name="storageProvider" />The market storage provider
public SiteCurrentMarket(IMarketService marketService, ICurrentMarketStorageProvider storageProvider)
{
this.marketService = marketService;
this.storageProvider = storageProvider;
}
/// <summary>
/// Gets the <see cref="IMarket" /> selected within the storage provider, if the value is
/// set and the indicated market is valid; ; otherwise, gets the default <see cref="IMarket" />.
/// </summary>
/// <returns>The current <see cref="IMarket" />.</returns>
public IMarket GetCurrentMarket()
{
string currentMarketId;
try
{
currentMarketId = this.storageProvider.Get();
}
catch (Exception ex)
{
currentMarketId = MarketId.Default;
}
var marketId = string.IsNullOrEmpty(currentMarketId) ? MarketId.Default : new MarketId(currentMarketId);
var market = this.marketService.GetMarket(marketId);
if (market == null && marketId != MarketId.Default)
{
market = this.marketService.GetMarket(MarketId.Default);
}
return market;
}
/// <summary>
/// Sets the current market, if <paramref name="marketId" /> represents a valid market;
/// otherwise, performs no action.
/// </summary>
/// <param name="marketId" />The market id.
/// <remarks>This will also set the current currency for the ECF context.</remarks>
public void SetCurrentMarket(MarketId marketId)
{
var market = this.marketService.GetMarket(marketId);
if (market != null)
{
this.storageProvider.Set(market.MarketId.Value);
SiteContext.Current.Currency = market.DefaultCurrency;
EPiServer.Globalization.ContentLanguage.PreferredCulture = market.DefaultLanguage;
}
else
{
throw new ArgumentException("Unknown MarketId when setting Current Market", "marketId");
}
}
}</pre>
<p>Note the ICurrentMarketStorageProvider interface being passed as a constructor parameter and also note the implementations of GetCurrentMarket() and SetCurrentMarket() now use the storage provider to retrieve and persist the current market. Now that we’ve abstracted the persistence out of ICurrentMarket lets implement some example storage providers.</p>
<h3>MembershipCurrentMarketStorageProvider</h3>
<pre style="width: 100%">using System;
using System.Web;
using System.Web.Profile;
/// <summary>
/// A membership based provider for storing a users current market.
/// </summary>
public class MembershipCurrentMarketStorageProvider : ICurrentMarketStorageProvider
{
private readonly HttpContextBase context;
public HttpContextBase Context
{
get
{
return context;
}
}
public virtual string MarketIdKey
{
get
{
return "MarketId";
}
}
public MembershipCurrentMarketStorageProvider()
{
this.context = new HttpContextWrapper(HttpContext.Current);
}
public MembershipCurrentMarketStorageProvider(HttpContextBase context)
{
this.context = context;
}
public virtual string Get()
{
var profileMarketId = string.Empty;
if (context != null && context.Profile != null)
{
if (context.Profile.GetPropertyValue(this.MarketIdKey) != null)
{
profileMarketId = context.Profile[this.MarketIdKey] as string;
}
}
return profileMarketId;
}
public virtual void Set(string value)
{
if (context != null && context.Profile != null)
{
var originalMarketId = context.Profile[this.MarketIdKey] as string;
if (!string.Equals(originalMarketId, value, StringComparison.Ordinal))
{
context.Profile[this.MarketIdKey] = value;
context.Profile.Save();
}
}
}
}</pre>
<p>This is pretty simple and is more or less a simple refactoring of the original MarketStorage example above. </p>
<h3>SessionCurrentMarketProvider</h3>
<pre style="width: 100%">using System.Web;
/// <summary>
/// A session based provider for storing a users current market.
/// </summary>
public class SessionCurrentMarketStorageProvider : ICurrentMarketStorageProvider
{
private readonly HttpSessionStateBase session;
public HttpSessionStateBase Session
{
get
{
return session;
}
}
public virtual string MarketIdKey
{
get
{
return "MarketId";
}
}
public SessionCurrentMarketStorageProvider()
{
this.session = new HttpSessionStateWrapper(HttpContext.Current.Session);
}
public SessionCurrentMarketStorageProvider(HttpSessionStateBase session)
{
this.session = session;
}
public string Get()
{
if (Session != null && Session[this.MarketIdKey] != null)
{
return Session[this.MarketIdKey].ToString();
}
return string.Empty;
}
public void Set(string value)
{
if (Session != null)
{
Session[this.MarketIdKey] = value;
}
}
}</pre>
<p>Again another simple implementation, that utilises Http session. </p>
<p><b>NOTE:</b> If you’re thinking of using this within production environments that are load balanced ensure server affinity is configured accordingly or you use permanent session storage techniques such as SQL Server or a State Server. </p>
<h3>CookieCurrentMarketStorageProvider </h3>
<pre style="width: 100%">using System;
using System.Web;
/// <summary>
/// A cookie based provider for storing a users current market.
/// </summary>
public class CookieCurrentMarketStorageProvider : ICurrentMarketStorageProvider
{
private readonly HttpContextBase context;
public HttpContextBase Context
{
get
{
return this.context;
}
}
public virtual string CookieName
{
get
{
return "Market";
}
}
public virtual string MarketIdKey
{
get
{
return "MarketId";
}
}
public virtual bool StoreAsSecureCookie
{
get
{
return false;
}
}
public CookieCurrentMarketStorageProvider()
{
this.context = new HttpContextWrapper(HttpContext.Current);
}
public CookieCurrentMarketStorageProvider(HttpContextBase context)
{
this.context = context;
}
public virtual string Get()
{
if (this.Context != null)
{
var httpCookie = this.Context.Request.Cookies[this.CookieName];
if (httpCookie != null)
{
return httpCookie[this.MarketIdKey];
}
}
return string.Empty;
}
public virtual void Set(string value)
{
if (this.Context != null)
{
var httpCookie = this.context.Request.Cookies[this.CookieName] ?? new HttpCookie(this.CookieName);
httpCookie[this.MarketIdKey] = value;
httpCookie.Expires = DateTime.Now.AddHours(2d);
httpCookie.Secure = this.StoreAsSecureCookie;
context.Response.Cookies.Set(httpCookie);
}
}
}</pre>
<p>Another fairly standard implementation.</p>
<h3>Configuration</h3>
<p>The only thing we need to do now is register the implementation within our <b>IConfigurableModule</b> and we’re away.</p>
<p>A point worth mentioning is that whenever you use a Storage Provider which utilises the HttpContext ensure that ICurrentMarketStorageProvider and ICurrentMarket are scoped accordingly.</p>
<h2>In Summary</h2>
<p>This approach allows your implementation of ICurrentMarket to remain unchanged across multiple clients/persistence requirements and allows your persistance mechanism to be interchangeable. This also provides the benefit of allowing your ICurrentMarket and your storage providers to be all testable. </p>
<p>So there you go… a pretty fundamental blog post which should hopefully highlight how small architectural changes can provide big benefits further down the line.</p>
<p>Thanks for reading</p>2014-08-12T17:09:34.0000000ZBlog post