CSMetal is a command line tool that reads Commerce Server 2009 metadata and generates a set of strongly-typed classes to use with the Commerce Foundation API and a set of Linq providers to allow access to Commerce Server entities via Linq.
It can dramatically simplify basic access to Commerce Server 2009 functionality by enabling simple Linq-syntax queries against most Commerce Server entities.
Sample unit tests are included that demonstrate the various access methods including a full checkout scenario.

This tool was created by Kerry Havas, Product Architect of the Commerce Server Product Unit.
It is not an official Microsoft release and is not supported by Microsoft Product Support.
Please use the discussion lists on MSDN Code Gallery to ask questions and provide feedback.

It is on MSDN code gallery here:

https://code.msdn.microsoft.com/csmetal

There are also a couple of sample applications, including a rewritten version of the "Orders" sample that comes with Commerce Server, which demonstrates the savings in overall code of using the Linq based queries and even a sample ASP.NET MVC 3 (Razor) application.
All source code is provided for the code generator and it may be modified to fit your need.

Questions/Comments can be posted here or on the Discussion tab in MSDN Code Gallery.

var updateCaches = new CommerceUpdate<CommerceEntity>("CommerceCache");updateCaches.SearchCriteria.Model.Properties["Name"] = "ProfileCache";
CommerceResponse updateResponse =  OperationService.ProcessRequest(currentContext, updateCache.ToRequest());

But what if you want to modify a particular instance in the cache, rather than blowing the whole cache away?

There is no out of the box way to do that in Commerce Server,  but its very easy to create a new message that does exactly that.

To start, create a new OperationSequenceComponent that encapsulates the Commerce Core Service functionality that clears a cache instance like below:

namespace Microsoft.Commerce.Samples.Pipelines
{
    class ProfileCacheInstance : OperationSequenceComponent
    {
        public override void ExecuteUpdate(CommerceUpdateOperation updateOperation, OperationCacheDictionary operationCache, CommerceUpdateOperationResponse response)
        {

            var modelSearch = (CommerceModelSearch)updateOperation.SearchCriteria;

            var eMail = modelSearch.Model.Properties["email"].ToString();

            // Get the Profiles run-time object.
            ProfileContext ctxt = CommerceContext.Current.ProfileSystem;

            // Get the profile from an eMail variable.
            Profile prof = ctxt.GetProfile("email_address", eMail, "UserObject");

            // Refresh the profile.
            prof.Refresh();

        }
    }
} 

Next, you add a reference to this handler in your CommerceConfiguration.config file like this:

<MessageHandler name="CommerceUpdateOperation_ProfileCacheInstance"        responseType="Microsoft.Commerce.Contracts.Messages.CommerceUpdateOperationResponse,            Microsoft.Commerce.Contracts, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35">
        <OperationSequence>
          <Component name="ProfileCacheInstance Updater"              type="Microsoft.Commerce.Samples.Pipelines.ProfileCacheInstance,             Microsoft.Commerce.Samples.Pipelines, Version=1.0.0.0, Culture=neutral,PublicKeyToken=b23706c1d1011ab9" />
        </OperationSequence>
      </MessageHandler>

To call this functionality, you can build a CommerceUpdate operation like this one:

var updateCaches = new CommerceUpdate<CommerceEntity>("ProfileCacheInstance"); 
updateCaches.SearchCriteria.Model.Properties.Add("email", “foo@foo.com”);

CommerceResponse updateResponse =  OperationService.ProcessRequest(currentContext, updateCache.ToRequest());

As you can see, it is quite easy to add a new message and a new handler that executes specific business functionality.  Now you have that business functionality in a nice discreet handler that can be reused in many projects.

While this was simple to do and worked great, as Brian pointed out in the comments, it doesn’t completely solve the problem.  As you can see, once we add that item to the basket, then the pricing reverts back to the original pricing.

The reason that this occurs is that basket calculations are not done in the Commerce Foundation, but are done down in the legacy COM-based pipelines.  The legacy pipelines actually query for product information directly to the database.  It does not go through the Commerce Foundation.  This means that are extension that we built never gets hit.

Lets open up the pipelin editor, which is in the tools folder and then navigate to the basket.pcf, which contains the sequence of components to run when the basket pipeline is run.

Fortunately for us, we know that it is the “QueryCatalogInfo” pipeline component, which is the first component that runs, that retrieves the basic information for a product and pushes it into the context for later use by other pipeline components.

So it would be nice to know what this component does.  The easiest way to do that is to turn on logging.  Pipelines can log everything read or written to the context, so it’s relatively easy to turn on logging and look at what the various components do.  To turn on logging, you go to the web.config and find the entry in the <pipelines> section and change logging to “true”.

pipeline name="basket" path="pipelines\basket.pcf" transacted="false" type="OrderPipeline" loggingEnabled="true" />

The basket pipeline runs every time you load the basket page, so it’s easy to see what happens by refreshing the basket page.  There should be a new folder underneath the Pipelines folder in your virtual directory which has file with an extension “.pipelog”  Open the “basket.pipelog” up in notepad and you should see a log of everything that the pipeline read or wrote during it’s execution.  The first pipeline component that executed is what we are interested in and so we can look at that:

This gives us a good idea of what this “QueryCatalogInfo” component does.  Now we have a couple of choices here.

1) We can create another com-based pipeline component that we put right after the "QueryCatalogInfo” component that adjusts the price per our business rules

2) We remove this legacy component and replace it with an OperationSequenceComponent that does the same thing.

If I want to simply stick another COM component in there then I end up having to run my rules-engine with any caching etc in two places.  I would much rather simply change the way the pipeline works so that it retrieves the product information using the Commerce Foundation, executing my pricing extension in the same way it does when I retrieve a product for display.

The other thing that you might notice is that it writes a lot of stuff into the context that you really don’t need because no other pipeline component uses them.  We can probably make something that is more simplified and only passes in information that we need.

What you might notice in looking at the above list of values read and written is that there are certain values that the pipeline assumes are already there.  For example, it assumes that there is an “Items” entry and it assumes that for each item in the items dictionary there is a productid, variantid, catalog,, catalog-language. 

So if those entries are already there, how did they get there?  The answer is that there is certain information pushed into the context by the Commerce Foundation before a pipeline is even run.  In our case the helper method for the basket pipeline knows that some elements of the orderform need to be in the pipeline context before it is run and it helpfully (hence the name…) copies them over for us.

Now if it loaded the orderform and directly copied the values into the context in the same OperationSequenceComponent, then we would have a very hard time extending it.  Luckily for us, this was something that was considered and it was broken into several operations.

If you open up the “channelconfiguration.config” file and search for “QueryOperation_basket” you will see the following entries:

<Component name="Basket Loader" type="Microsoft.Commerce.Providers.Components.BasketQueryProcessor, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35" /> 
          …

          <Component name="Order Pipelines Processor" type="Microsoft.Commerce.Providers.Components.OrderPipelinesProcessor, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35">
            <Configuration customElementName="OrderPipelinesProcessorConfiguration" customElementType="Microsoft.Commerce.Providers.Components.

OrderPipelinesProcessorConfiguration, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35">
              <OrderPipelinesProcessorConfiguration>
                <!--
                 The name attribute should contain one of the Order pipeline names defined in the pipelines section of the CommerceServer site configuration.
                 The type attribute should contain one of the values of the Microsoft.CommerceServer.Runtime.Orders.OrderPipelineType enumeration:
                       Custom       Indicates a custom pipeline type.
                       Product      Indicates a Product pipeline (e.g. Product.pcf).
                       Basket       Indicates a Basket pipeline (e.g. Basket.pcf).
                       Total        Indicates a Total pipeline (e.g. Total.pcf).
                       Checkout     Indicates a Checkout pipeline (e.g. Checkout.pcf).
                       AcceptBasket Indicates an AcceptBasket pipeline (e.g. AcceptBasket.pcf).
               -->
                <OrderPipelines>
                  <Pipeline name="basket" type="Basket" />
                  <Pipeline name="total" type="Total" />
                </OrderPipelines>
              </OrderPipelinesProcessorConfiguration>
            </Configuration>
          </Component>

You see that there is a “Basket Loader” component that runs first.  This loads the basket and places it in the operationCache.  Later the “Order PipelinesProcessor” runs and this takes that cached order and writes it into the context.

This is great because we have the ability to inject our own logic between those two entries that modifies the basket object in the operationCache and adds our additional information to the basket line items.

So we can write a new OperationSequenceComponent that looks like this:

What this component does is retrieve the basket from the operationCache, walk through each of it’s order forms and each line and calls out to the foundation to retrieve data for each item.  This will then execute the “QueryOperation_Product” which will execute our custom pricing rule.  The retrieved data is then copied into the order forms lineItem dictionary.

This means that when the basket is copied into the context later on in the component sequence, it will already have those values in place that the QueryCatalogInfo is supposed to put there.  So we can remove that piepline component so that it will not run.

We strong-name, build and GAC the component above and we can go into the “channelconfiguration.config” file and add this new components into the list right above the “Order Pipelines Processor” component in the “QueryOperation_basket” message handler.  Note that the “Order Pipeline Processor” component is called from a number of message handlers and we need to add this entry above each one:

<Component name="QueryCatalogInfo" type="Microsoft.Commerce.Samples.Pipelines.QueryCatalogInfo, Microsoft.Commerce.Samples.Pipelines, Version=1.0.0.0, Culture=neutral,PublicKeyToken=b23706c1d1011ab9" />

It looks like we have everything configured now, so lets restart IIS (give it a clean slate) and refresh the basket again and see what we get.

Amazingly enough, my basket now contains the pricing generated by my pricing engine.  I’ve also removed a legacy com-based component from a pipeline which is executed quite a lot, which gives me more control of the overall solution.

 All of the out-of-the-box functionality, which wraps the Commerce Core Services is implemented as Operation Sequence Components.

The Operation Sequence Components that get called when a particular message comes through the foundation is defined in the ChannelConfiguration.config file.  This file has an entry for every message and a list of components to call to build up a response to that message.

<MessageHandler name="CommerceQueryOperation_Product" responseType="Microsoft.Commerce.Contracts.Messages.CommerceQueryOperationResponse, Microsoft.Commerce.Contracts, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35">
  <OperationSequence>
    <Component name="Product Query Processor" type="Microsoft.Commerce.Providers.Components.ProductLoader, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35">
      <Component name="Cross-Sell Provider" type="Microsoft.Commerce.Providers.Components.ProductCommerceServerRelationshipProcessor, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35">
        <Configuration customElementName="CommerceServerRelationshipConfiguration" customElementType="Microsoft.Commerce.Providers.Components.CommerceServerRelationshipConfiguration, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35">
          <CommerceServerRelationshipConfiguration commerceServerRelationshipName="CrossSell" internalRelationshipName="CrossSells" />
        </Configuration>
      </Component>
      <Component name="Up-Sell Provider" type="Microsoft.Commerce.Providers.Components.ProductCommerceServerRelationshipProcessor, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35">
        <Configuration customElementName="CommerceServerRelationshipConfiguration" customElementType="Microsoft.Commerce.Providers.Components.CommerceServerRelationshipConfiguration, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35">
          <CommerceServerRelationshipConfiguration commerceServerRelationshipName="UpSell" internalRelationshipName="UpSells" />
        </Configuration>
      </Component>
      <Component name="Product Variant Provider" type="Microsoft.Commerce.Providers.Components.ProductVariantProcessor, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35" />
      <Component name="ProductAncestorCategoryProcessor" type="Microsoft.Commerce.Providers.Components.ProductAncestorCategoryProcessor, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35" />
      <Component name="ProductCanonicalCategoryProcessor" type="Microsoft.Commerce.Providers.Components.ProductCanonicalCategoryProcessor, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35" />
      <Component name="ProductParentCategoryProcessor" type="Microsoft.Commerce.Providers.Components.ProductParentCategoryProcessor, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35" />
      <Component name="ProductPrimaryCategoryProcessor" type="Microsoft.Commerce.Providers.Components.ProductPrimaryCategoryProcessor, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35" />
      <Component name="ProductRelatedCategoryProcessor" type="Microsoft.Commerce.Providers.Components.ProductRelatedCategoryProcessor, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35" />
      <Component name="ProductRelatedProductProcessor" type="Microsoft.Commerce.Providers.Components.ProductRelatedProductProcessor, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35" />
      <Component name="ProductInventoryItemsProcessor" type="Microsoft.Commerce.Providers.Components.ProductInventoryItemsProcessor, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35" />
      <Component name="Product catalog relationship" type="Microsoft.Commerce.Providers.Components.ProductCatalogRelationshipProcessor, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35" />
      <Component name="Product base catalog relationship" type="Microsoft.Commerce.Providers.Components.ProductBaseCatalogRelationshipProcessor, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35" />
      <Component name="Product Discounts Relationship" type="Microsoft.Commerce.Providers.Components.CatalogEntityDiscountsProcessor, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35" />
    </Component>
  </OperationSequence>
</MessageHandler>

This creates a great extensibility model because you can create your own custom Operation Sequence Component and insert it before, after or in between the out-of-the-box Operation Sequence Components.  You can even replace the out-of-the-box components with your own if you want to connect to an LOB system or create your own customer data providers.

If you create a component and insert it before the out-of-the-box components, then you have an opportunity to examine and/or modify the query.  If you insert the component after, then you can examine and/or modify the results that will be returned.

It’s possible, for example to implement a component that executes business logic to modify the price of a product based on certain conditions.

As a simple, albeit ridiculous, example, suppose I wanted to lower the price of my products to $1 if it is Saturday.

To start with I would create a new class in Visual Studio like this:

using Microsoft.Commerce.Providers.Components;
using Microsoft.Commerce.Contracts;

namespace Microsoft.Commerce.Samples.PriceEngine
{
    public class PriceEngine:OperationSequenceComponent
    {
        public override void ExecuteQuery(Microsoft.Commerce.Contracts.Messages.CommerceQueryOperation queryOperation, Microsoft.Commerce.Broker.OperationCacheDictionary operationCache, Microsoft.Commerce.Contracts.Messages.CommerceQueryOperationResponse response)
        {
            if (System.DateTime.Now.DayOfWeek == System.DayOfWeek.Saturday)
            {
                foreach (var commerceEntity in response.CommerceEntities.FindAll(c => c.ModelName == "Product"))
                {
                    commerceEntity.Properties["ListPrice"] = 1;
                    foreach (var variant in commerceEntity.Properties["Variants"] as CommerceRelationshipList)
                    {
                        variant.Target.Properties["ListPrice"] = 1;
                    }
                }
            }
        }
    }
}

Now sign, build and copy this component to the GAC.

Next open up the ChannelConfiguration.config file and add an entry to the end of the list of compoents to call when a product is retrieved.

<MessageHandler name="CommerceQueryOperation_Product" responseType="Microsoft.Commerce.Contracts.Messages.CommerceQueryOperationResponse, Microsoft.Commerce.Contracts, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35">
        <OperationSequence>
          <!—out-of-the-box components here—>
          <Component name="PriceEngine" type="Microsoft.Commerce.Samples.PriceEngine.PriceEngine, Microsoft.Commerce.Samples.PriceEngine, Version=1.0.0.0, Culture=neutral,PublicKeyToken=c70c9a2d1f784c32" />
         
        </OperationSequence>
      </MessageHandler>

Now, when a product is retrieved, it will automatically execute your additional business logic and reduce the price to $1 when it is Saturday.

Obviously, you can execute much more complex logic or even call out to an external pricing service.

Unfortunately, I had to hard code the setting into the OSC like this:

categoryConfiguration.InventoryOptions.FilterOutOfStockSkus = true;

Now, if I ever want to change that setting, I have to go in and change the code, recompile and redeploy.  It would be great if I could make that configurable so that I  can change it through configuration whenever I want without having to alter the code.

Fortunately, Commerce Server Operation Sequence Components have a way to facilitate configuration quite easily.

To start with, we take the OSC that I created in my last post:

Next, we need to create a class to store the configurable elements:

Next, we need to implement the IConfigurable interface into the OnHandFilter class:

Now, we change our hard coded value to read from the configuration:

You can now compile and deploy this component to the GAC.

Next, open up your ChannelConfiguration.config file and go find the “QueryOperation_Category” section that was modified in the previous blog post to add the new OnHandFilter OSC.  Alter the entry to include the new configuration setting.

So we are ready to test this now.  To test it, we take the Adventureworks, out of the box contemporary site and we modify the Polar Star sleeping bag to have an OnHandQuantity of 0.

Now when go to the Sleeping Bags category, we should no longer see the Polar Star product returned:

Now, if you go back and set the FilterOutOfStockSkus to False, the product should show back up again:

Now you can extend this concept to add configuration points for all of the settings available in the CategoryConfiguration object.

This filter setting is stored in the CategoryConfiguration object which Commerce Server passes into the core subsystems when retrieving a category.

Although you cant change the out of the box component, you can change the CategoryConfiguration object that it uses.

When Commerce Server retrieves a category it first checks the operationCache for a copy of the CategoryConfiguration and then creates a default one, if it is not found.

If you want to override the default behavior, what you need to do is create an OperationSequenceComponent that executes right before the “Category_Loader” OSC in the QueryOperation_Category operation like this:

This is your ChannelConfiguration.config:

      <MessageHandler name="CommerceQueryOperation_Category" responseType="Microsoft.Commerce.Contracts.Messages.CommerceQueryOperationResponse, Microsoft.Commerce.Contracts, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35">

        <OperationSequence>

      <!—This one is added à

          <Component name="OnHandFilter" type="Microsoft.Commerce.Samples.OnHandFilter, OnHandFilter, Version=1.0.0.0, Culture=neutral,PublicKeyToken=62d299e5f36470e7">

            <!—This one is added à

          <Component name="Category_Loader" type="Microsoft.Commerce.Providers.Components.CategoryLoader, Microsoft.Commerce.Providers, Version=1.0.0.0, Culture=neutral,PublicKeyToken=31bf3856ad364e35" />

The component would look like this:

public class OnHandFilter:OperationSequenceComponent

    {

        public override void ExecuteQuery(Microsoft.Commerce.Contracts.Messages.CommerceQueryOperation queryOperation, Microsoft.Commerce.Broker.OperationCacheDictionary operationCache, Microsoft.Commerce.Contracts.Messages.CommerceQueryOperationResponse response)

        {

            var categoryConfiguration = new Microsoft.CommerceServer.Catalog.CategoryConfiguration();

            categoryConfiguration.InventoryOptions = new Microsoft.CommerceServer.Inventory.InventoryOptions();

            categoryConfiguration.InventoryOptions.FilterOutOfStockSkus = true;

            operationCache.Add("CategoryContentSelectorKey_D6E2DE05-01E0-4a35-BF26-BCF95971B8D1", categoryConfiguration);

        }

    }

You can actually override any of the CategoryConfiguration properties this way.

I tested the above on our out of the box site and it does what you are looking for.

You could further enhance this by making a single generic OperationSequenceComponent that exposes those configuration properties in the CategoryConfiguration object as configurable properties.

I will explore that in my next blog entry.

CGF - Computer Grog Factor.

 This is the amount of time it takes from when you take your computer out of sleep mode until it becomes usable. 

Right now this is top of mind because the CGF on my laptop has been getting a lot worse.  It now takes 15 minutes after I come out of sleep mode for me to be able to use Outlook.  Now, to be fair, I am running Server 2008 with SQL Server 2008, MOSS, IIS, etc running so there is a lot of stuff that has to spin back up.

Still, I would like to have access to my computer a lot faster.  You constantly see people walking around with their laptops open.  The reason they do this is because they dont want the expense of closing their laptop, having it go to sleep, and then reopening it again and waiting for their computer to awake and start listening for instructions.

What's your CGF?

You can access it here: https://channel9.msdn.com/pdc2008/PC59/

Tom does a great demo where he constructs a working E-Commerce site in about 5 minutes using the out of the box Commerce Server "Mojave" web parts.

It really shows how powerful this new release really is.

https://blogs.msdn.com/commerce/default.aspx