
Beginning of april it was time for the yearly Sitecore Usergroup meeting in Europe: SUGCON 2019. The venue location was this time the City of London.

The conference started with a keynote by Donovan Brown, Principal Azure Devops manager at Microsoft.
Donovan presented the possibilities and advantages of using DevOps by using a nice anology between DevOps and Formula One with respect to pitstop optimizations: http://donovanbrown.com/post/DevOps-before-and-after-F1-style
DevOps is an interesting and applicable subject as Sitecore, especially since version 9.0, is more and more becoming a micro-service oriented architecture. A very interesting SUGCON kick-off!

## Sitecore Commerce & JSS – Pramila Soni & Saurabh Sachdeva
An introduction in the use of Sitecore Javascript Services (JSS) and Commerce was presented by Pramila Soni and Saurabe Sachdeva. 
Using practical examples Pramila and Saurabh showed how you can use a current XC9 installation with JSS. There is no official support (yet) from Sitecore for this scenario, e.g. in the form of official Commerce JSS components, but using it is already quite well possible.
In short, a very interesting session as start for a future investigation of Sitecore Commerce and JSS.

[slides](https://www.sugcon.eu/wp-content/uploads/2019/04/SUGCON-Europe-2019-Pramila-Soni-Saurabh-Sachdeva-Sitecore-Commerce-and-JSS.pdf)

## I struggled with Sitecore on Docker so you don’t have to – Sean Holmesby
Sean Holmesby gave a fun presentation about how as a Docker newby, but experienced Sitecore developer, you can improve your workflow using Docker.
Main roadblocks Sean found were;

- Docker for Windows and understanding new concepts to get started, e.g. what is a Docker registry and how does that compare to a Docker repository?
- How to build Docker images (Sitecore does not ship Docker images)?

It was great to see that Sean his session attracted a room full op people. A good indication that there is large interest within the Sitecore community for Docker.
Something that I, and Aviva Solutions, have been investing quite some effort in and is publicly available on Github: https://github.com/avivasolutionsnl/sitecore-docker

## How to extend the Sitecore Commerce business tools - Erwin Werkman
Erwin Werkman presented a detailed overview of how to modify and extend the Sitecore XC9 Business Tools (aka BizFx).
Adding new properties to the Business Tools is quite straightforward, but only if you exactly know what to do! Exactly this aspect is really important when working with Sitecore XC9 and something that Erwin clearly explained.

It gets more complicated when you want to extend the Business Tools, with e.g. custom buttons, and changes are needed in the BixFx AngularJS application. For this Erwin showed an approach which is documented in this Github repo: https://github.com/ewerkman/bizfx-extension
To conclude, customizing the BizFx tools is possible, but when you need more customization it gets more complicated and less developer friendly.

[slides](https://www.sugcon.eu/wp-content/uploads/2019/04/SUGCON-Europe-2019-Erwin-Werkman-Extending-the-Sitecore-Commerce-Business-Tools.pdf)


SUGCON Europe 2019 - London 💂

Sitecore 9 can be slow to start, which is especially annoying during development.
Below are some configuration tweaks to speed it up.

## Scheduling
Put some agents on low rotation:
```
<scheduling>
    
    <agent type="Sitecore.ListManagement.Operations.UpdateListOperationsAgent, Sitecore.ListManagement">
        <patch:attribute name="interval">00:30:00</patch:attribute>
    </agent>

    <agent type="Sitecore.ContentSearch.SolrProvider.Agents.IndexingStateSwitcher, Sitecore.ContentSearch.SolrProvider">
        <patch:attribute name="interval">08:00:00</patch:attribute>
    </agent>

    
    <agent name="Core_Database_Agent">
        <patch:attribute name="interval">00:00:00</patch:attribute>
    </agent>
    <agent name="Master_Database_Agent">
        <patch:attribute name="interval">00:00:00</patch:attribute>
    </agent>
</scheduling>
```

## Processors
Remove some processors that are not needed during development:
```
<pipelines>
    <initialize>
        <processor type="Sitecore.Pipelines.Loader.ShowVersion, Sitecore.Kernel">
        <patch:delete />
        </processor>
        <processor type="Sitecore.Pipelines.Loader.ShowHistory, Sitecore.Kernel">
        <patch:delete />
        </processor>
        <processor type="Sitecore.Analytics.Pipelines.Initialize.ShowXdbInfo, Sitecore.Analytics">
        <patch:delete />
        </processor>
        <processor type="Sitecore.Pipelines.Loader.DumpConfigurationFiles, Sitecore.Kernel">
        <patch:delete />
        </processor>
    </initialize>
</pipelines>
```

## Application settings
Disable EXM in `Web.config` (see [here](https://gary.wenneker.org/performance-tuning-sitecore-ludicrous-speed/) for details):
```
<appSettings>
    
    <add key="exmEnabled:define" value="no"/>
    ...
</appSettings>
```

Switch optimize compilations on in `Web.config` (see [here](https://herodigital.com/2018/01/11/improving-sitecores-start-up-time/) for details):
```
<compilation ... optimizeCompilations="true">
    ...
</compilation>
```

## Credits
Many optimizations were taken from articles I found. Special thanks go out to the following persons:

- Ethan Schofer:
https://herodigital.com/2018/01/11/improving-sitecores-start-up-time/
- Gary Wenneker: https://gary.wenneker.org/performance-tuning-sitecore-ludicrous-speed/
- Per Bering:
https://gist.github.com/pbering/e3866e452c75e030e710f62d267dbb4e

Speed up Sitecore 9 start


The performance of the current Catalog import in XC9 update-2 is not so good. This article gives a few tips on how to speed up the import process.
After applying these optimizations, importing a sellable item costs about 15 msec.

## Do not use the ICreateRelationshipPipeline and limit IPersistEntityPipeline usage
The `ICreateRelationshipPipeline` is expensive; do not use it. Instead create the relations yourself. At the same time limit the number of writes (ie. `IPersistEntityPipeline` calls) by keeping objects as much as possible in memory.

For example to import a sellable item with a category relation:

1. Create the category (and keep it in memory):
    ```
    var category = new Category
    {
        Id = id,
        ...
    };

    Task<PersistEntityArgument> task = persistEntityPipeline.Run(new PersistEntityArgument(category), context);
    await task;

    category = task.Result.Entity as Category;
    ```

2. Create sellable item and relate it to the category:
    ```
    // 2. Create sellable item
    var sellableItem = new SellableItem
    {
        ...
        ParentCatalogList = arg.Catalog.SitecoreId,
        ParentCategoryList = parentCategory.SitecoreId,
        ...
    };

    Task<PersistEntityArgument> task = persistEntityPipeline.Run(new PersistEntityArgument(sellableItem), context);
    ```

3. Update the category once after all sellable items are added to it:
    ```
    persistEntityPipeline.Run(new PersistEntityArgument(category), context);
    ```

## Patch IPersistEntityPipeline
Remove indexing related blocks as these dramatically decrease performance:
```
.ConfigurePipeline<IPersistEntityPipeline>(c =>
{
        c.Remove<Sitecore.Commerce.Plugin.Search.AddEntityToIndexListBlock>()
        .Remove<Sitecore.Commerce.Plugin.Catalog.IndexUpdatedSitecoreItemBlock>();
})
```
Manually trigger a full catalog index rebuild.

## Clean up context to keep memory usage under control
By default XC9 caches all processed entities. This makes it use more and more memory. As we only write entities, we can clear the context cache after each async import batch (e.g. after each batch of 100 sellable items):
```
context.CommerceContext.ClearEntities();
context.CommerceContext.ClearModels();
context.CommerceContext.ClearObjects();
```

## Do not re-index during an import
By default the Minion task triggers a catalog re-index every 5 minutes, this obviously bad for performance (especially while importing).
Currently the best way to prevent re-indexes during import is either:

- Do not start the Minion

- Change the `WakeupInterval` for the Minion:
    ```
    {
            "$type": "Sitecore.Commerce.Core.MinionPolicy, Sitecore.Commerce.Core",
            "WakeupInterval": "08:00:00",
            ...
    }
    ```


Speed up the Catalog Import process


The XC9 Entity Composer functionality is introduced in update-2, and this [article](https://community.sitecore.net/technical_blogs/b/technical-marketing/posts/experience-commerce-entity-composer) describes the concept and explains how to add Entity Composer templates using the Business Tools.

In this article we describe how to programmatically add Entity Composer templates.
This is for example useful when writing your own catalog importer.


Creating a template, adding it to a sellable item, and filling a property value requires the following steps:

* Create an Entity Composer template
* Add an item definition to the catalog
* Link template to an item definition
* Link sellable item to item definition
* Set a property value for a sellable item
* Link the entity view to the Entity Composer template

The next sections describe each step in detail.

## Create an Entity Composer template
First step is to create a template, named "My example template", and make it visible in the Business Tools by adding it to the proper list.
The template has one property named "My example property".
```
var templateEntityViewComponent = new EntityViewComponent();

// Create compose template
var template = new ComposerTemplate(CommerceEntity.IdPrefix<ComposerTemplate>() + name)
{
    Name = "MyTemplate",
    DisplayName = "My example template",
    Components =
    {
        // List membership is used to show to templates in the Business Tools overview
        new ListMembershipsComponent
        {
            Memberships =
            {
                string.Format("{0}", CommerceEntity.ListName<ComposerTemplate>())
            }
        },

        templateEntityViewComponent
    }
};

// Create an Entity View that holds the properties
var entityView = new EntityView
{
    Name = name, // This name should be different than the ComposerTemplate name. See Sitecore bug #276414.
    DisplayName = name,
    DisplayRank = 0,
    Icon = "piece"
};
entityView.SetItemIdForComposerView(); // This is the ItemId you will need to link in the sellable item

templateEntityViewComponent.View.ChildViews.Add(entityView);

// Add a property
var viewProperty = new ViewProperty
{
    Name = "MyPropertyName",
    DisplayName = "My example property",
    OriginalType = "System.String",
    IsRequired = false, // By default a property is not required
    RawValue = "" // This is necesary to please the CatalogTemplateGenerator (present in XC9 update-3)
};

// The CatalogTemplateGenerator requires a DateTimeOffset to be filled with a compatible value (present in XC9 update-3)
if (viewProperty.OriginalType == "System.DateTimeOffset")
{
    viewProperty.RawValue = System.DateTimeOffset.Now;
}

entityView.Properties.Add(viewProperty);

// Persist the template
await persistEntityPipeline.Run(new PersistEntityArgument(template), context);
```
Note that Entity Composer templates are stored in the `CommerceEntities` table (of the `SharedEnvironments` database).
Above code was largely reverse-engineered from the `Sitecore.Commerce.Plugin.Composer.ComposerCommander` class.

## Add an item definition to the catalog
To link the template to a sellable item we will use the item definition approach.
For this we first need to indicate on the catalog which item definitions are allowed.
```
var catalog = new Catalog(); 

var itemDefinitionsComponent = new ItemDefinitionsComponent() 
{
    Definitions = new List<string>{ "MyDefinition" }
}

catalog.SetComponent(itemDefinitionsComponent);
```

## Link template to item definition
Now link the template to the newly created Item Definition.
```
template.SetComponent(
    new ItemDefinitionsComponent
    {
        Definitions = new List<string> { "MyDefinition" }
    }
);
```

## Link sellable item to item definition
To link the sellable item to the item definition;
```
sellableItem.Components.Add(new CatalogsComponent {
    ChildComponents =
    {
        new CatalogComponent
        {
            Name = "MyCatalog",
            ItemDefinition = "MyDefinition"
        }
    }
});
```

## Set a property value for a sellable item
To add a property value for the linked template we need to;
- create an entity view with the same name as the template, 
- add a property with matching name, 
- and add it to the sellable item.
```
// Create an EntityView that holds the properties
var propertyEntityView = new EntityView
{
    Name = "MyDefinition",
    DisplayRank = 0,
    Icon = "piece" // Same as Business Tools adds by default
};
propertyEntityView.ItemId = entityView.ItemId; // Use the item id of the composer template entity view

var viewProperty = new ViewProperty
{
    IsRequired = false,
    Name = "MyPropertyName",
    OriginalType = "System.String",
    RawValue = "My test value"
};

propertyEntityView.Properties.Add(viewProperty);

// Link the EntityView to the Sellable Item
propertyEntityView.EntityId = sellableItem.Id;

sellableItem.Components.Add(new EntityViewComponent
{
    View = 
    {
        ChildViews =
        {
            propertyEntityView
        }
    }
});
```

## Link the entity view to the Entity Composer template
The final step is to track which entity view belongs to which composer template.
```
var composerTemplateViewsComponent = new ComposerTemplateViewsComponent();
composerTemplateViewsComponent.TrackComposerTemplateView(propertyEntityView.ItemId, CommerceEntity.IdPrefix<ComposerTemplate>() + "MyDefinition");

sellableItem.Components.Add(composerTemplateViewsComponent);
```

# Remarks
The Entity Composer functionality is brand new, and while reverse engineering how to programmatically do it, we bumped against some (to be solved) unclearities and bugs:

- Property values cannot be set for product variants. The `CatalogDataProvider` however generates templates for variants, and somehow some values get filled. This is a limitation of the current implementation in XC9 update-2.

- The `CatalogDataProvider` throws an error when properties do not have `RawValue` set (in JSON). As a result you will not see any values in the Sitecore Content Editor. Workaround is either always filling a value, or patching `CatalogDataProvider.GetItemFields` with following code (see [this](https://sitecore.stackexchange.com/questions/13498/xc9-entity-composer-error-when-rawvalue-is-not-present/13499#13499) post):
    ```
    var val = property[(object)"Value"].Value<string>() ?? String.Empty;
    fieldList1.Add(templateField.ID, val);
    ```

- Circular template inheritance error; the generated template inherits from its self. This occurs when the `ComposerTemplate` has a `EntityView` with the same name, and is registered as bug #276414 by Sitecore.


April 8, 2019

SUGCON Europe 2019 - London 💂

September 25, 2018

Speed up Sitecore 9 start

September 24, 2018

Speed up the Catalog Import process

August 29, 2018

Programmatically adding Entity Composer templates