Blog posts by Antti Alasvuo2025-11-30T16:04:41.0000000Zhttps://world.optimizely.com/blogs/Antti-Alasvuo/Optimizely WorldMastering Optimizely DXP: How to Download Blobs Like a Pro with PowerShell<p>In 2021 I wrote a <a title="Step by step instructions to download DXP blobs" href="/link/bfe815302aae4a888f3ee5384a49d322.aspx">blog post with detailed instuctions</a> on how to download blobs from Optimizely DXP environment. I at least have used that blog post ever since as my notes "What were the steps" when ever I've needed to download projects blobs to my local. But every time I've downloaded blobs I have thinked that I should write a simple PowerShell script that does all the steps for me after I have provided the API credential and environment information. It would be also nice, if the script would print out the container names and I could select which container to download.</p>
<p>Well it took me four years to find the time to write the PowerShell script but here it is.</p>
<h2>Prerequisities</h2>
<ul>
<li>EpiCloud PowerShell module installed
<ul>
<li>Optimizely <a title="EpiCloud module" href="https://docs.developers.optimizely.com/digital-experience-platform/docs/deploy-using-powershell">EpiCloud module</a> install and other documentation related to it</li>
</ul>
</li>
<li>AzCopy installed
<ul>
<li>Download Microsoft <a title="Download AzCopy" href="https://learn.microsoft.com/en-us/azure/storage/common/storage-use-azcopy-v10#download-azcopy">AzCopy</a></li>
</ul>
</li>
<li>Optimizely DXP API credential or access to PAAS-portal to create API credential</li>
<li><a title="PowerShell script to download Optimizely DXP blobs" href="https://gist.github.com/alasvant/f41f8ffec7826b94efdc1b5796ae4d36">Get my script</a> from GitHub Gist (might be updated in future) and save it as download-dxp-blobs.ps1, or use the one this page</li>
</ul>
<p>You can check my old blog post for the <a title="install instructions" href="/link/bfe815302aae4a888f3ee5384a49d322.aspx">install instructions</a>.</p>
<h2>Using the PowerShell script</h2>
<ul>
<li>Open command prompt and navigate to the folder where you have the script</li>
<li>The Optimizely EpiCloud module is not signed and therefore You have to run PowerShell bypassing execution policy, so in command prompt run the following command:
<ul>
<li><code>powershell.exe -ExecutionPolicy Bypass</code></li>
</ul>
</li>
<li>Now execute the script with the required arguments
<ul>
<li><code>& .\download-dxp-blobs.ps1</code>
<ul>
<li><code>-ApiKey [your API key]</code></li>
<li><code>-ApiSecret [your API secret]</code></li>
<li><code>-ProjectId [your project id]</code></li>
<li><code>-Environment [Optimizely DXP environment string]</code></li>
<li><code>-DownloadPath [path where to download in double quotes]</code></li>
<li><code>-RetentionHours [how many hours SAS link is valid]</code>
<ul>
<li>This is optional, default is four hours</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
<p>Sample command:</p>
<pre class="language-html"><code>& .\download-dxp-blobs.ps1 -ApiKey 1234567890123456238937223 -ApiSecret 9874677436746763443434dsaJKDSSJKHD -ProjectId 4D50395E-3805-498E-AD8C-82D7F530A596 -Environment Production -DownloadPath "C:\Downloads\DXP\ProjectXBlobs" -RetentionHours 6</code></pre>
<p>Sample output from the script:</p>
<p><img src="/link/1af2ef6f570841a187d140e7d6518680.aspx" alt="" width="1100" height="323" /></p>
<p> </p>
<h3>PowerShell script for reference</h3>
<p>Here is the script for reference, but you can also get it from <a title="PowerShell script to download Optimizely DXP blobs" href="https://gist.github.com/alasvant/f41f8ffec7826b94efdc1b5796ae4d36">this gist</a>.</p>
<pre class="language-html"><code># Simple script to download Optimizely DXP blobs
# Created by Antti Alasvuo
# https://github.com/alasvant
# https://world.optimizely.com/blogs/Antti-Alasvuo/
#
# Gist: https://gist.github.com/alasvant/f41f8ffec7826b94efdc1b5796ae4d36
#
# ApiKey, ApiSecret and ProjectId You get from Optimizely PAAS-portal (DXP Management Portal) from API tab,
# create new API credential there if you don't have one yet
#
# Environment: Integration, Preproduction or Production
#
# DownloadPath, is the path where the selected container is downloaded to
#
# RetentionHours, how many hours the created SAS link is valid (how long this script can access the containers blobs)
# Default is 4 hours, you should ensure it is greater value than how long it takes to download all the blobs
# Get needed arguments for Optimizely cmd-lets
param (
[Parameter(Mandatory)]
[string]
$ApiKey,
[Parameter(Mandatory)]
[string]
$ApiSecret,
[Parameter(Mandatory)]
[string]
$ProjectId,
[Parameter(Mandatory)]
[string]
$Environment,
[Parameter(Mandatory)]
[string]
$DownloadPath,
[int]
$RetentionHours = 4
)
# Not using Connect-EpiCloud because then when calling Get-EpiStorageContainer the "table"
# output is printed to console where ever I try to redirect the output :D
Write-Host 'Getting DXP containers..'
Write-Host ''
$containers = Get-EpiStorageContainer -ClientKey $ApiKey -ClientSecret $ApiSecret -ProjectId $ProjectId -Environment $Environment | Select-Object -ExpandProperty storageContainers
# Just a counter used in the loop to have not zero based numbers in the selection
$foreachCounter = 1
foreach ($containerName in $containers)
{
Write-Host ("{0}) {1}" -f ($foreachCounter++), $containerName)
}
$selectedIndex = -1
do
{
$isInputValid = [int]::TryParse((Read-Host 'Enter container number (and press enter)'), [ref]$selectedIndex)
if ((-not $isInputValid))
{
Write-Host 'Invalid value entered.'
}
elseif (($selectedIndex -lt 1) -or ($selectedIndex -gt $containers.length))
{
Write-Host 'Invalid number selected for container.'
$isInputValid = $false
}
} while (-not $isInputValid)
$selectedContainerName = $containers[$selectedindex-1]
Write-Host ''
Write-Host ("Selected container: {0}" -f $selectedContainerName)
Write-Host ''
Write-Host 'Acquiring SAS link..'
$sasLink = Get-EpiStorageContainerSasLink -ClientKey $ApiKey -ClientSecret $ApiSecret -ProjectId $ProjectId -Environment $Environment -StorageContainer $selectedContainerName -RetentionHours $RetentionHours | Select-Object -ExpandProperty sasLink
Write-Host 'SAS link acquired.'
Write-Host ''
Write-Host 'Starting download using azure copy.'
Write-Host ''
azcopy copy $sasLink $DownloadPath --recursive
Write-Host "Done."</code></pre>
<p> </p>
<p>Footer note: Would you have guessed that the blog post heading was created by Copilot :D</p>
<p> </p>2025-11-30T16:04:41.0000000ZBlog postSwapcode.Optimizely.AuditLog updated to v1.4.1<p>If you are using my audit log add-on Swapcode.Optimizely.AuditLog then I suggest that you update it in your solution.</p>
<p>I've been waiting now for few years for Optimizely to fix the styles used in the Change Log tool in admin view, but seems like they don't have time to fix the styles for the table.</p>
<p>In the past the log messages have not been visible without using browser developer tools to see the HTML source..</p>
<p><img src="/link/8f8b41f7dda6497f91c5d196b10b3ca7.aspx" /></p>
<p>In this new version I've changed the structure of the activity log entry, and now you can see usually most of the relevant information.</p>
<p><img src="/link/0baeaffb018447cf897284e642ab6c7f.aspx" /></p>
<p>There is still issue with the Change Log styling, you need to scroll the table to right, and the last column size depends on your browser window size, but there is nothing I can do about it ;-D</p>
<p>Another change I did was I added a new extension method for IServiceCollection, AddAuditLog(), which you should start using instead of the old way.</p>
<pre class="language-csharp"><code>// replace old code
services.AddEmbeddedLocalization<AuditLogInitializationModule>();
// with the new extension method, which should be done after call to .AddCms()
.AddAuditLog();</code></pre>
<p>The add-on is still using the initialization module to register the event handlers but this is preparation to change the implementation in a following update, so the AddAuditLog method actually just currently registers the embedded resources ;-)</p>
<p>The updated NuGet package should show up to the Optimizely NuGet feed shortly, but in the meantime you can manually get the updated NuGet package from my GitHub <a href="https://github.com/alasvant/Swapcode.Optimizely.AuditLog/releases/tag/v1.4.1">repository releases</a>.</p>2023-05-20T09:21:07.0000000ZBlog postFix failing Remove Unrelated Content Assets Optimizely scheduled job<p>Our Remove Unrelated Content Assets scheudled job started to fail with message "<em>The DELETE statement conflicted with the REFERENCE constraint "FK_tblContentProperty_tblContent2". The conflict occurred in database "epicms", table "dbo.tblContentProperty", column 'ContentLink'.</em>". All we knew some heavy content deletion and imports were done, but that is normal work supported by CMS (maybe not done in such magnitude often, but anyways). <strong>@Optimizely</strong> hint, that error message in scheduled job views is pretty useless - we have no real data like the offending content id to easily try to understand what is wrong.</p>
<p><img src="/link/970c635497fa4e4caf3ee3ca75b2b022.aspx" /></p>
<p>So at this stage we only know that something is failing in database because of a constraint but we have no clue what content is causing this.</p>
<h3>What content is causing the issue</h3>
<p>So next step is, how do we figure out the content causing this - I did remember from past that the EPiServer.DataAccess.Internal.ContentSaveDB does actually log content ids but on DEBUG level.</p>
<p>So what I did was get the DXP database exported and restored to local environment and then changed the log4net logging level to log everything.</p>
<p>So in your log4net (usually in Optimizely CMS 11 projects named by default EPiServerLog.config) you need to change under root node the level node value to All or Debug, and then also in the appender configuration comment out the threshold node or change its value to Debug for example.</p>
<p>Now when executing the job we get a lot more logging and should look in the log file just before the exception is logged.</p>
<pre class="language-markup"><code>DEBUG EPiServer.DataAccess.Internal.ContentSaveDB: Deleting content 65015
ERROR EPiServer.DataAbstraction.ScheduledJob: Job EPiServer.Util.CleanUnusedAssetsFoldersJob failed for the job 'Remove Unrelated Content Assets' with jobId ='e652f3bd-f550-40e8-8743-2c39cda651dc'
System.Data.SqlClient.SqlException (0x80131904): The DELETE statement conflicted with the REFERENCE constraint "FK_tblContentProperty_tblContent2". The conflict occurred in database "preprod-cms", table "dbo.tblContentProperty", column 'ContentLink'.</code></pre>
<p>I've cleaned a bit of trace messages away from the above log snippet, but you get the point from it.</p>
<p>Now we can see that the system is about to delete content with id 65015 and that is the content id that causes the exception.</p>
<h3>Manage content</h3>
<p>Now that we know the content id we can navigate to CMS edit mode and modify the url to contain the offending content id like so <em>#context=epi.cms.contentdata:///<strong>65015</strong>&viewsetting=viewlanguage:///en</em> and hit enter to navigate to that content. In our case this was a content assets folder and it contained some images, but there is no way to delete this content from edit mode.</p>
<p>But what about the "Manage content" tool in admin view under tools? If you would just simply navigate to the "Manage content" tool you would see site(s) resources in hierarchial view and thats it, but there is an old trick. Right click "Manage Content" under tools and select to open link in new tab, switch to the new tab and look at the url, this should give you the hint that the page accepts content id as url paramter. Edit the url and enter the offending content id to the url, in our case ManageContent.aspx?id=65015 and hit enter.</p>
<p><img src="/link/cf8a9283cdec43dfbba2393342308e45.aspx" /></p>
<p>It looks like nothing changed BUT you are now actually editting that content with content id 65015. So our goal was to get rid of this content, so click "<em>Move to trash</em>" button (not the Delete, there is a reason for it).</p>
<p>The page will reload and the id in url changes to 4 (content asset folder root), the id might be different in your case if the type of the content was something else.</p>
<p>Next switch to edit view and go to trash (View Trash). Now you should see the content in trash.</p>
<p><img src="/link/44cf4e0d4dc44d57a50f16e7ae768120.aspx" /></p>
<p>Before I moved the content to Trash, I had emptied the trash, so all content is now something that can be emptied from trash. In our case the content was the content folder so all content inside it can be seen here too. You can hover your mouse cursor over the folder and you can see it has the content id we just moved (like double checking). Next step is to delete the content from trash, you can use the "Empty Trash" button or one by one delete item(s).</p>
<h3>Execute Remove Unrelated Content Assets</h3>
<p>Final step is to check did we correct the issue, so navigate to admin view and then manually start the Remove Unrelated Content Assets scheduled job.</p>
<p><img src="/link/e0427d115f6d4d859396d84744b6627e.aspx" /></p>
<p>Success!</p>
<h3>Outro</h3>
<p>In the Content Management view I instructed to press the "Move to trash" button instead of "Delete" as there was a reason for it. I think I initially tried that approach and it didn't work but I'm writing this blog post a month after I wrote the steps down, so I really don't remember anymore for sure and I don't have time to setup this again :D But if recall correctly it has to with how the job is implemented, it reads "events" from "Change log" and if the delete button was used in the Manage Content some info is still missing and it will not work, so it really needs to be done -> move to trash and then delete.</p>2023-02-09T10:26:55.0000000ZBlog postOptimizely Forms uploaded attachments authentication issue with OpenID Connect<p>Customer is using <a href="https://docs.developers.optimizely.com/integrations/v1.1.0-apps-and-integrations/docs/optimizely-forms">Optimizely Forms</a> to create various editor designed/configured forms to the website. In our case one had the option for the end-user to upload images using the form, and when the form was successfully submitted then an email was sent to editors containing also direct links to the uploaded images.</p>
<p>Initially no one complained anything about the functionality, until one day a bug ticket was raised "I get authentication error when I click the uploaded file link."</p>
<p>Navigating to the uploaded file link from email in an incognito browser indeed showed OpenID Connect authentication error and from logs we could see the full reason:</p>
<pre class="language-markup"><code>// Error message split on multiple lines for easier reading
Microsoft.IdentityModel.Protocols.OpenIdConnect.OpenIdConnectProtocolInvalidNonceException: IDX21323: RequireNonce is '[PII is hidden. For more details, see https://aka.ms/IdentityModel/PII.]'.
OpenIdConnectProtocolValidationContext.Nonce was null, OpenIdConnectProtocol.ValidatedIdToken.Payload.Nonce was not null.
The nonce cannot be validated. If you don't need to check the nonce, set OpenIdConnectProtocolValidator.RequireNonce to 'false'. Note if a 'nonce' is found it will be evaluated.</code></pre>
<p>The second line says what happened, validation context nonce is null but payload nonce wasn't and therefore nonce cannot be validated.</p>
<p>Nonce is used to prevent replay attacks and is on by default in Microsoft implementation (see Optimizely documentation <a href="https://docs.developers.optimizely.com/content-cloud/v11.0.0-content-cloud/docs/integrate-azure-ad-using-openid-connect">Integrate Azure AD using OpenID Connect</a> for CMS 11 / .NET Framework 4.x), and by default you should not turn off this feature, it is on by default for a reason ;-) And as a side note, by default Optimizely Forms uploaded files are access restricted, otherwise someone from Internet could access any of the files if they could guess the urls.</p>
<h2>Investigation, what goes wrong?</h2>
<p>In development environment everything works as expected - even when user is not authenticated and navigates to the file url the authentication flow works correctly, editor is authenticated and then can access the uploaded files.</p>
<p>Back to the "<em>Nonce</em>", when a user is not logged in and the authentication flow is started the redirect to authentication sets a nonce cookie named "OpenIdConnect.nonce.[generated-characters-here]", and this nonce cookie is used by the validator when the user returns from the authentication. So we can confirm that this cookie is correctly set in development environment but when checking this in DXP there is no nonce cookie set by the response.</p>
<p>As we know that CloudFlare is used in front of the DXP services which basically is Azure App Service (with some goodies), could the issue then be in CloudFlare configuration, so that it doesn't pass the nonce cookie to client in this case?</p>
<p>We contacted the Optimizely Support and got the confirmation that the default CloudFlare cache rule cause this behavior.</p>
<h2>Solution</h2>
<p>Uploaded files are stored under the "File upload" Forms element, under folder "Uploaded Files". You can check the uploaded files by editing the Optimizely Forms form (Form container) => edit the "File upload" Forms element and then go to the "Media tab" and scroll to "For This Block" and expand the node and you can see the "Uploaded Files" folder.</p>
<p>As we know the files get the url from the structure, for example "my-demo.file.png" would get something like this as the url "/contentassets/ae5ba1d328f2532122679f73da8d1578/uploaded-files/my-demo-file_547166305085297447.png", so based on that we could have an ignore pattern like "/contentassets/*/uploaded-files/*", to not use caching and to allow the authentication flow to work correctly.</p>
<p>We contacted Optimizely support, and they added this new rule to CloudFlare for our customer, and now the authentication flow works correctly. Do note that you should only ask for this in the case you really need it, as this is not default configuration (at least not at the time when I wrote about this).</p>2022-12-27T13:05:28.0000000ZBlog postCustom placeholders in Optimizely Forms submission emails<p>In this post I'll show you how you can easily create your own custom placeholders and use those in Optimizely Forms.</p>
<p>The idea for this blog post came from the requirement of a customer project where they wanted to have the Forms submit timestamp in an email (email sent when a user submits a form).</p>
<p>By default only the fields editor has added to the Forms form are available in the placeholders (summary field is a special placeholder) but when a form is submitted by the user there are also the system columns like:</p>
<ul>
<li>hosted page, from what page the form was submitted</li>
<li>timestamp, when the form was submitted</li>
<li>language, language of the forms FormContainerBlock</li>
<li>user, username of th euser if the user was logged in</li>
</ul>
<p>So in this customer case we already have the forms submitted timestamp and would be ideal to just be able to use that instead of starting to create a completely custom email sending functionality, just to be able to add a timestamp to the email. <a href="https://docs.developers.optimizely.com/content-cloud/v1.2.0-forms/docs/placeholder-api">Optimizely Plaholder API</a> to the rescue ;-) ...yes yes it is still in beta, but it has been that for a long time (<a href="/link/76974ad8d2a84c1b989ad0ac453ab663.aspx?releaseNoteId=AFORM-854&amp;amp;amp;epsremainingpath=ReleaseNote/">Improve PlaceHolder API (BETA)</a>).</p>
<h2>Custom placeholder provider</h2>
<p>Implementing a custom placeholder provider is as easy as creating a class that implements the interface <strong><em>EPiServer.Forms.Core.Internal.IPlaceHolderProvider</em></strong> from <strong>EPiServer.Forms.Core.dll</strong> (EPiServer.Forms.Core NuGet package).</p>
<p>The interface defines two properties and one method:</p>
<ul>
<li>int Order { get; set; }<br />
<ul>
<li>Priority of the PlaceHolderProvider to process AvailablePlaceHolders</li>
</ul>
</li>
<li>IEnumerable<PlaceHolder> ExtraPlaceHolders { get; }
<ul>
<li>Custom PlaceHolders will be merged into AvailablePlaceholders</li>
</ul>
</li>
<li>IEnumerable<PlaceHolder> ProcessPlaceHolders(IEnumerable<PlaceHolder> availablePlaceHolders, FormIdentity formIden, HttpRequestBase requestBase = null, Submission submissionData = null, bool performHtmlEncode = true);
<ul>
<li>Called when "replacing" the placeholders with the actual data</li>
</ul>
</li>
</ul>
<h3>Define your custom placeholders</h3>
<p>In the ExtraPlaceHolders property we define the custom placeholders this provider supports:</p>
<pre class="language-csharp"><code>// Note the placeholder key value is what is displayed in placeholder dropdown
/// <summary>
/// Form submitted placeholder.
/// </summary>
private const string FormSubmittedTimestamp = "Form submitted";
/// <summary>
/// Form submitted by user placeholder.
/// </summary>
private const string FormSubmittedBy = "Form submitted by";
/// <summary>
/// Form submitted from page placeholder.
/// </summary>
private const string FormSubmittedFromPage = "Form submit page";
public IEnumerable<PlaceHolder> ExtraPlaceHolders => new PlaceHolder[] {
new PlaceHolder(FormSubmittedTimestamp, null),
new PlaceHolder(FormSubmittedBy, null),
new PlaceHolder(FormSubmittedFromPage, null)
};</code></pre>
<p>The PlaceHolder object takes two arguments:</p>
<ul>
<li>First the "<em>Key</em>" which is the placeholder string</li>
<li>Second is the value</li>
</ul>
<p>So here three placeholder strings are created and "<em>null</em>" is used for the value for all of them.</p>
<h3>Process custom placeholders</h3>
<p>The replacement of the placholders are done in the ProcessPlaceHolders method. Extension methods used in the code are available in <a href="https://gist.github.com/alasvant/b114f32c0f991efbbe0a628a6fe6ddee">GitHub Gist</a>.</p>
<pre class="language-csharp"><code>public IEnumerable<PlaceHolder> ProcessPlaceHolders(IEnumerable<PlaceHolder> availablePlaceHolders, FormIdentity formIden, HttpRequestBase requestBase = null, Submission submissionData = null, bool performHtmlEncode = true)
{
if (availablePlaceHolders == null)
{
// the DefaultPlaceHolderProvider throw null exception too if the availablePlaceHolders is null
// the interface documentation doesn't say anything about exceptions (which ones should be thrown)
// so do it the same way
throw new ArgumentNullException(nameof(availablePlaceHolders));
}
// get the submission data
var data = submissionData?.Data;
// if we don't have data, then do nothing
if (data == null)
{
return availablePlaceHolders;
}
//
// NOTE! Extension methods used in this code can be seen in gist:
// https://gist.github.com/alasvant/b114f32c0f991efbbe0a628a6fe6ddee
//
foreach (var ph in availablePlaceHolders)
{
if (FormSubmittedTimestamp.Equals(ph.Key, StringComparison.Ordinal))
{
// get the submitted timestamp
if (data.TryGetSubmitTime(out DateTime submitted))
{
data.TryGetLanguage(out string languageCode);
try
{
// the timestamp is DateTimeKind.Utc, format the timestamp using
// the forms culture or the default culture
ph.Value = $"{submitted.ToString(GetCultureInfo(languageCode))} UTC";
}
catch {}
}
}
else if(FormSubmittedBy.Equals(ph.Key, StringComparison.Ordinal))
{
// get the submitted by user
if (data.TryGetSubmitUser(out string username))
{
ph.Value = string.IsNullOrWhiteSpace(username) ? AnonymousUsername : username;
}
else
{
ph.Value = AnonymousUsername;
}
}
else if (FormSubmittedFromPage.Equals(ph.Key, StringComparison.Ordinal))
{
// get the form hosted page
if (data.TryGetHostedPage(out ContentReference hostedPage))
{
LoaderOptions loadingOptions;
// try to get the language code
if (data.TryGetLanguage(out string languageCode))
{
loadingOptions = new LoaderOptions { LanguageLoaderOption.FallbackWithMaster(GetCultureInfo(languageCode)) };
}
else
{
loadingOptions = new LoaderOptions { LanguageLoaderOption.MasterLanguage() };
}
// try to load the content in the forms language and fallback to masterlanguage
if (_contentLoader.Service.TryGet(hostedPage, loadingOptions, out PageData page))
{
// and then resolve the url using the language the content was actually loaded in
var pageUrl = _urlResolver.Service.GetUrl(page);
ph.Value = $"{page.Name}, {pageUrl}";
}
}
}
}
return availablePlaceHolders;
}</code></pre>
<h2>Custom placeholders in action</h2>
<p>Now the editor can use the custom placeholders in the email template.</p>
<p><img src="/link/6a9d81aea97448bbb93369222759034e.aspx" /></p>
<p>And then in the email we can see the values like this:</p>
<p><img src="/link/5f6a758385f24831a0c4decd2496fa12.aspx" /></p>
<ul>
<li><em>Form submitted</em>, is formatted using the culture of the submitted form, in these samples in Finnish, Swedish and English</li>
<li><em>Form submitted by</em>, anonymous or the logged in user</li>
<li><em>Form submitted from page</em>, contains page name in the correct culture and the url of the page</li>
</ul>
<h2>Full source code in GitHub gists</h2>
<ul>
<li><a href="https://gist.github.com/alasvant/b114f32c0f991efbbe0a628a6fe6ddee">FormSubmissionDataExtensions.cs</a></li>
<li><a href="https://gist.github.com/alasvant/5cfe6b643ecef37cdc31d9a85abc7383">FormsSystemColumnsPlaceholderProvider.cs</a></li>
</ul>2022-06-18T11:54:03.0000000ZBlog postUsing dotnet CLI to create your new Optimizely project<p>As everyone knows Optimizely CMS and Commerce have entered the .NET 5 era a while back. There is not yet much blog posts or Optimizely help documentation how you actually create the solution with projects and other needed files in a real world project. Lets face it, we don't create new solutions daily and even the seasoned developers might forget "what they were supposed to do when starting a new customer project". So here is my take to add to the existing guides and documentation.</p>
<h3>What do we want to achieve?</h3>
<ul>
<li>we want to have a solution</li>
<li>which has two projects
<ul>
<li>one for CMS</li>
<li>one class library (lets pretend we will place our content models here)</li>
</ul>
</li>
<li>it has a nuget.config which includes the Optimizely NuGet feed</li>
<li>(it is a shame that the .editorconfig template is not available with SDK 5.x but comes in SDK 6.x otherwise that would have been added here too)</li>
<li>added to version control</li>
</ul>
<p>And the solution would look like this in Visual Studio (ignore the readme.txt in the image)</p>
<p><img src="/link/ad81c1d92fa74385941bd385574e0535.aspx" alt="Image vs-solution.png" /></p>
<h3>Prerequisites</h3>
<ul>
<li>You need to have Visual Studio v16.8 or newer installed (comes with 5.0.100 .NET 5 SDK)</li>
<li>Optimizely templates and Episer CLI tool installed
<ul>
<li>see install instructions from the "<a href="/link/b8dfde46279b431cab83e33c62168130.aspx">Setting up development environment</a>" documentation</li>
</ul>
</li>
<li>(optional: git, if not having ;-) then skip the git commands)</li>
</ul>
<h2>dotnet CLI commands to create the solution</h2>
<pre class="language-csharp"><code>// open command prompt and create a new folder which will hold the solution, projects and other files
mkdir MyAwesomeSolution
cd MyAwesomeSolution
// initialize git
git init
// OPTIONAL: this step is mandatory only if you have .NET 6 SDK(s) installed
// as the default is that the latest SDK is used, with global.json we can "lock" to a certain version
dotnet new globaljson --sdk-version 5.0.100
// open the created global.json in a text editor and add "allowPrerelease" and "rollForward" properties (and save it)
// we don't allow prereleases and we allow latest minor SDK version upgrades, so we stick to the 5.x versions
{
"sdk": {
"allowPrerelease": false,
"version": "5.0.100",
"rollForward": "latestMinor"
}
}
// next create the solution file
dotnet new sln -n "My Awesome Solution"
// create a folder to hold the sources, its common to have the source files/projects under 'src' folder
mkdir src
// next add the empty CMS project to the src folder
// -n is used for the project name
// -o is used to specify where the output from template should be placed in
dotnet new epicmsempty -n MyCompany.Web -o src\MyCompany.Web
// next add the class library
dotnet new classlib -n MyCompany.ContentTypes -o src\MyCompany.ContentTypes
// next the projects need to be added to the solution
// NOTE! The --in-root is used so that the command doesn't create a "src" solution folder
// but places the projects directly under the solution, remove the --in-root option to create a solution folder
dotnet sln "My Awesome Solution.sln" add --in-root src/MyCompany.Web/MyCompany.Web.csproj
dotnet sln "My Awesome Solution.sln" add --in-root src/MyCompany.ContentTypes/MyCompany.ContentTypes.csproj
// next we need nuget.config
dotnet new nugetconfig
// and then we need to add the Optimizely NuGet feed to it
dotnet nuget add source https://nuget.optimizely.com/feed/packages.svc -n "Optimizely NuGet Feed"
// and then add the gitignore file
dotnet new gitignore
// and then stage and commit our files
git add -A
git commit -m "Initial commit."</code></pre>
<h3>Open the solution in Visual Studio</h3>
<p>Now it is time to open the solution in Visual Studio, and you should be able to build it and all should be fine.</p>
<p>But remember the step where the nuget.config was added? At least I'm used to have the nuget.config visible in "Solution Items", but we never added that file to the solution using "dotnet sln add...", well there is a reason for that - currently you can only add project files with the "dotnet sln add" command, so if you want to have the file in "Solution Items" you need to do it in Visual Studio.</p>
<h3>Running the created solution</h3>
<p>So we created empy Optimizely CMS site but we have no database for it or edit/admin user.</p>
<p>As the default empty site is configured to use ASP.NET Identity we can use the <em>dotnet-episerver</em> tool to create the database and add an admin user. Minimal documentation for the tool can be found from the "<a href="/link/893f1ecd15be4522a18bc054c8a59dbd.aspx">Creating a starter project</a>" documentation or from the tool itself by executing "<em>dotnet-episerver --help</em>" for general help and then same can be used for details on the command usage like "<em>dotnet-episerver create-cms-database --help</em>".</p>
<pre class="language-csharp"><code>// create databse for CMS
// -S is the server and instance where the database will be created, so in my case local machine and SQLEXPRESS named instance
// -E means that integrated security aka Windows authentication is used (using my credentials) when connecting to the database server
// if the database server uses only SQL authentication or your identity don't have access then you shouldn't use -E but -U and -P to define the SQL credentials to connect to the server
// -dn is the database name to be created
// -du is the user to be created that is used by the website to access the DB
// -dp is the users password
dotnet-episerver create-cms-database src\MyCompany.Web\MyCompany.Web.csproj -S .\sqlexpress -E -dn "MyCompanyWeb" -du "mycompanywebuser" -dp "W3RySeCre7!2021"
// next add the "admin" user
// -u is the username
// -p is the password
// -c is the connection string name (see MyCompany.Web projects appsettings.json)
dotnet-episerver add-admin-user src\MyCompany.Web\MyCompany.Web.csproj -u mycompanyuser -p MySecret!2021 -e mycompanyuser@local.local -c EPiServerDB</code></pre>
<p>After the above commands have been executed do note that adding the admin user generates a log file (log.txt), and naturally you don't want to have this added to version control, so delete the file (its placed to the solution root folder, where the command was executed from). Don't forget to commit your changes.</p>
<p>Now you can run the website and login to edit/admin views with the created user, so hit F5. Browser naturally tries to request the root of the website and as there is no content, you need to manually change the address to the default Optimizely CMS edit url "/episerver/cms/" and hit enter.</p>
<p><img src="/link/ed129b04d91a402983432a12f4a0b6d0.aspx" /></p>
<p>Happy happy, joy joy ;-)</p>2021-12-12T12:03:53.0000000ZBlog postAudit logging add-on for netcore-preview<p>The .Net 5 public review has now been out for 2+ months and if you have missed that you definitely need to read post by Martin Ottosen <a href="/link/1bc8e0286e4348c8b0d527ca35b5cfe9.aspx">.Net 5 public preview</a>, read the <a href="/link/3ba6f4e13c99477fa35bcab293f3c66c.aspx">.Net 5 preview documentation</a> and have a look at the GitHub <a href="https://github.com/episerver/netcore-preview">netcore-preview repository</a>.</p>
<p>Roughly a year ago I created the <a href="https://nuget.optimizely.com/package/?id=Swapcode.Episerver.AuditLog">Swapcode.Episerver.AuditLog</a> package to log access right changes to the built-it activity log (Change log), you can see <a href="https://swapcode.wordpress.com/2020/09/05/swapcode-episerver-auditlog-is-now-available-in-episerver-nuget-feed/">old post about it</a>.</p>
<p>I had some free time, so I decided why not prepare the package for the .NET 5 implementation and at the same time rename it to reflect the new Optimizely name. Code can be found from my GitHub repository <a href="https://github.com/alasvant/Swapcode.Optimizely.AuditLog">Swapcode.Optimizely.AuditLog</a> and pre-built NuGet package from the <a href="https://github.com/alasvant/Swapcode.Optimizely.AuditLog/releases">releases</a> (not in any feed as it is just a preview version, <a href="https://github.com/alasvant/Swapcode.Optimizely.AuditLog/releases/download/v1.0.0-preview.1/Swapcode.Optimizely.AuditLog.1.0.0-preview.1.nupkg">first version direct download link</a>).</p>
<h3>Installing the package</h3>
<ul>
<li>download the NuGet package</li>
<li>create a local (disk or network share) NuGet source, and add the NuGet package there</li>
<li>configure the new source in Visual Studio / NuGet.config of your project</li>
<li>check the 'Include prerelease' checkbox in Visual Studio so that you will see package</li>
<li>install it to your project</li>
<li>add configuration for the embedded localizations in your startup class, in ConfigureServices method after a call to services.AddCms();</li>
</ul>
<pre class="language-csharp"><code>services.AddEmbeddedLocalization<AuditLogInitializationModule>();</code></pre>
<h3>Usage</h3>
<p><img src="/link/d45855ae69b04d65a9e500b720ec3831.aspx" /></p>
<ul>
<li>login to Optimizely CMS</li>
<li>navigate to Admin view -> Access Rights -> Set Access Rights
<ul>
<li>change a content items access rights</li>
</ul>
</li>
<li>go to Admin view -> Tools -> Change Log
<ul>
<li>in 'Category' select 'Content security'</li>
<li>in 'Action' select what kind of entries you want to see</li>
<li>click 'read'</li>
</ul>
</li>
</ul>
<p>The following screenshot shows how the results look like. Note there is a small issue with the data column, the content is not completely visible because of the preview versions CSS styles (but clever users can inspect the column with browsers developer tools to see the full message). Hopefully Optimizely will do something about that data column, so I don't need to format the message with br-tags :D</p>
<p><img src="/link/a85b4430f81d40f4931c6ce707712db7.aspx" /></p>
<h3>Summary</h3>
<p>So, if you have been using this add-on then you can be sure it will be available also for the next .NET 5 version of Optimizely CMS.</p>2021-09-12T13:15:51.0000000ZBlog postHow to download blobs from Optimizely (Episerver) DXP environment<p>Ever wanted to download the blobs from Optimizely DXP environment but don't know how to? In this post I will clarify the process how to download blobs from DXP environment and what tools you need to accomplish it.</p>
<p>As we develop our customer solutions there quite often comes the situation that instead of creating some dummy content we would like to grap for example the latest content and blobs from the DXP production environment and work with that. As you might know the DXP service is built on top of Azure services you might think that you would simply login to the Azure Portal and navigate to the storage resources and get blobs from there, but as this is a service we don't get direct access to the underlying Azure resources via Azure Portal.</p>
<p>Optimizely DXP has a self-service portal which allows us to do deployments, view application logs, copy content between environments and download content from DXP envrionment but this is limited to the database BACPAC file which doesn't include the blobs which we naturally also require. Optimizely DXP documentation has the information on how to get the blobs but that information is spread on multiple pages and no single page howto to exists (at least to my knowledge ;-) so that is the reason for this blog post). Just in case you don't know how to <a href="/link/e857f1af908f40c0840a704ff8b640d8.aspx">export the database to BACPAC file in DXP</a> and how to <a href="/link/858d3e9c8a7a41c7afab709a3e0558a4.aspx">get access to the self-service portal</a>.</p>
<p><em><strong>EDIT 2025-11-30</strong></em>, I've written a new <a title="Download Optimizely DXP blobs like a pro with PowerShell script" href="/link/dc53a6a1c6d244e5aa6f4cff43c87371.aspx">blog post which contains a PowerShell script</a> to do all this with just single command, so if You end up here, you might want to have a look at that.</p>
<h1>Download blobs from Optimizely DXP environment</h1>
<p>Before you continue to the actual process ensure you have access to DXP self-service portal or a team mate can provide you with an environments API information (project ID, client secret and key).</p>
<p>Rest of the post assumes you have access to the DXP self-service portal and we are settings things up from scratch.</p>
<h2>Prerequisities</h2>
<ul>
<li>EpiCloud PowerShell module installed
<ul>
<li>Optimizely <a href="/link/eb85a23d0c1843aaa36f121668e1059e.aspx#install">EpiCloud module install and other documentation</a> related to it</li>
</ul>
</li>
<li>AzCopy installed
<ul>
<li>Microsoft <a href="https://docs.microsoft.com/en-us/azure/storage/common/storage-use-azcopy-v10#download-azcopy">AzCopy download</a></li>
</ul>
</li>
<li>access to DXP self-service to create API credentials</li>
</ul>
<h3>Install EpiCloud PowerShell module</h3>
<p>If this is your first time you install any PowerShell modules from <a href="https://www.powershellgallery.com/">PSGallery</a> you should add it as a trusted source to avoid warning when installing modules from there.</p>
<ul>
<li>open Windows PowerShell
<ul>
<li>check is the PSGallery already added by running command
<ul>
<li>
<pre>Get-PSRepository</pre>
</li>
<li>if you get output listing PSGallery with InstallationPolicy 'Trusted' you can skip the next command to add it as a trusted source</li>
</ul>
</li>
<li> add PSGAllery as trusted source with the following command
<ul>
<li>
<pre>Set-PSRepository -Name 'PSGallery' -InstallationPolicy Trusted</pre>
</li>
</ul>
</li>
<li>install EpiCloud module with the following command
<ul>
<li>
<pre>Install-Module -Name EpiCloud -Scope CurrentUser</pre>
</li>
<li><strong>NOTE!</strong> The EpiCloud module is not signed so when you use it you need to run the PowerShell session with "<strong><em>powershell.exe -ExecutionPolicy -Bypass</em></strong>" (and note the correct capitalization)</li>
</ul>
</li>
</ul>
</li>
</ul>
<h3>Download and install AzCopy</h3>
<p>Download the latest version from Microsoft AzCopy page: <a href="https://docs.microsoft.com/en-us/azure/storage/common/storage-use-azcopy-v10#download-azcopy">https://docs.microsoft.com/en-us/azure/storage/common/storage-use-azcopy-v10#download-azcopy</a></p>
<p>AzCopy is delivered as a zip file and you can extract it anywhere you like. I would suggest that you put it somewhere you have other tools that don't have an installer and you have added that location to your system or user path (in Windows) so that you can easily execute it from anywhere (without using always the full path to the executable).</p>
<h3>Create DXP API credential for the environment</h3>
<ul>
<li>Login to the Optimizely DXP self-service portal</li>
<li>Select the customer (organization) you want to create the API credential</li>
<li>Switch to the API tab</li>
<li>Under the 'Deployment API credentials' click 'Add API Credentials' button
<ul>
<li>Give a name for the API Credential</li>
<li>Select to which environments the API credential can be used to</li>
<li><img src="/link/94a1d204110540a4abea71da35c851ca.aspx" /></li>
<li>Click 'Save'</li>
<li><strong>IMPORTANT!</strong> After you have clicked Save, you should copy the 'API Secret' value as this is the only time you can do it! If you forget to copy and store it securely in this step, just create a new API Credential</li>
</ul>
</li>
</ul>
<h2>Download blobs from DXP environment</h2>
<p>The following commands assume we have created API Credential for production environment and we will download blobs from production, but the same applies to any other DXP environment as long you use correct environments API Credentials and correct 'Environment name' in cmdlets that require you to define it.</p>
<p>EpiCloud module has these three <strong>environment names</strong>: Integration, Preproduction and Production</p>
<ul>
<li>Open Windows PowerShell</li>
<li>Start a new PowerShell session that bypasses execution policy (needed because the EpiCloud module is not signed) with the following command (<strong>NOTE!</strong> you have to use the correct capitalization of ExecutionPolicy and the value Bypass, otherwise the bypass policy is not applied)
<ul>
<li>
<pre>powershell.exe -ExecutionPolicy Bypass</pre>
</li>
</ul>
</li>
<li>Set the Optimizely API credential for the session, so that you don't need to pass those as arguments to the EpiCloud module each time with the following command
<ul>
<li>
<pre>Connect-EpiCloud -ClientKey Your-ClientKey -ClientSecret Your-ClientSecret -ProjectId Your-ProjectId</pre>
<ul>
<li>ClientKey is the 'API key' value from API Credential</li>
<li>ClientSecret is the 'API secret' value from API Credential</li>
<li>ProjectId is the 'Project Id' value from API Credential</li>
</ul>
</li>
<li>now we have the "authentication" for the API setup and we can use the EpiCloud modules cmdlets</li>
</ul>
</li>
<li><em>Optional</em>, get the containers for production environment with the following command (not needed if you know the container name):
<ul>
<li>
<pre>Get-EpiStorageContainer -Environment "Production"</pre>
</li>
<li>the command will return you the columns "projectId", "environment" and "storageContainers"
<ul>
<li>for example: azure-application-logs, azure-web-logs and name-of-your-blob-container
<ul>
<li>the blob container name is naturally the container name you have defined for that environment in your web.config, <a href="/link/f8095ba67d6243d5960675015884e355.aspx#blobproviders">episerver.framework blob</a> section</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
<li>To be able to download the blobs we need a SAS token (Shared Access Signature) for the blob storage container, execute the following command
<ul>
<li>
<pre>Get-EpiStorageContainerSasLink -Environment "Production" -StorageContainer "your-site-assets-container-name-here" -RetentionHours 1 | Format-Table sasLink -AutoSize -Wrap</pre>
<ul>
<li>-Environment, one of the EpiCloud environment strings listed in the start</li>
<li>-StorageContainer, the container name you have defined for the blobs</li>
<li>-RetentionHours, integer how many hours the SAS token is valid for (use short time)</li>
<li>Without piping the cmdlet to Format-Table, command would output 5 "columns": projectId, environment, containerName, sasLink and expiresOn</li>
<li>copy the sasLink value as you will need that as input to the AzCopy command, just be sure when you paste the url for AzCopy that it doesn't contain any extra whitespaces or line feeds</li>
</ul>
</li>
</ul>
</li>
<li>Next step is to download the blobs
<ul>
<li>AzCopy will need the path where to download the blobs, so decide the location where you will want to download the blobs
<ul>
<li>do note that you don't need to create the "container name" folder in your local path as AzCopy will "replicate" the structure from the storage</li>
<li>for example, you define local path c:\blobs-from-prod\2021-06-13 (this needs to exist)
<ul>
<li>and the container name is 'siteassets', then AzCopy will create that 'siteassets' under the c:\blobs-from-prod\2021-06-13 path</li>
</ul>
</li>
</ul>
</li>
<li>Execute command to copy the blobs
<ul>
<li>
<pre>azcopy copy "sasLink value here inside the double quotes" "your destination path inside double quotes" --recursive</pre>
<ul>
<li>note there are two hyphens before the recursive argument, this means that the blobs are copied recursively under the container (read: all blobs are copied to destination)</li>
</ul>
</li>
<li>how long does it take? depends on how many blobs there are and how fast your internet connection is
<ul>
<li>for example, with 1Gbps connection it took less than a minute to copy 3,6GB (3331 files) =D</li>
</ul>
</li>
<li><img src="/link/5979eed365554a3ab6c2b92000e33164.aspx" /></li>
</ul>
</li>
</ul>
</li>
</ul>
<h3>Summary</h3>
<p>I've covered the tools and steps you need to do, to be able to download blobs from Optimizely DXP environment. Easy & Fast. Hopefully this short "how to" helps you in your projects.</p>2021-06-13T14:54:01.0000000ZBlog postRemove Unrelated Content Resources scheduled job failing<p>This is quick post about a situation where the Episerver scheduled job "Remove Unrelated Content Resources" started to fail because of a database constraint. I would say that this is a really rare case (seen it happen only in two projects) but sharing the information just in case you face the same thing in your project so you are able to solve it quicker ;-)</p>
<p>So when this error occurs the scheduled job records error message "<em>The DELETE statement conflicted with the REFERENCE constraint "FK_tblContentProperty_tblContent2". The conflict occurred in database "YOUR-DB-NAME-HERE", table "dbo.tblContentProperty", column 'ContentLink'.</em>". No that helpful message :-/ something wrong in the database BUT you would be interested to know what content caused the issue, so you might head to your applications error logs and hope to see the offending content id there, but sadly it is not logged (<strong>WINK</strong>, Episerver maybe change the scheduled job and/or the ContentDB to log the offending content id?).</p>
<h2>Remove Unrelated Content Resources scheduled job</h2>
<p>So the job is defined in <em>EPiServer.dll</em> and the class is <em>CleanUnusedAssetsFoldersJob</em> in <em>EPiServer.Util</em> namespace. Having a look at the code in <a href="https://github.com/icsharpcode/ILSpy/releases">ILSpy</a> I could track the code path and see if there are any places where I would get some log messages to help find the offending content id. I was lucky, the code eventually endsup to the '<em>ContentSaveDB.Delete(ContentReference contentLink, bool forceDelete)</em>' method (in EPiServer.dll, namespace <span>EPiServer.DataAccess.Internal). In that method there is a debug log message writen before the content is deleted using the a stored procedure 'editDeletePage' which takes the content id and boolean force delete parameters.</span></p>
<h2><span>Log messages from ContentSaveDB.Delete</span></h2>
<p><span>So next we need to modify our logging to log debug messages from the ContentSaveDB class. Here is a sample using the Episerver default log4net logging framework, if you have replaced log4net with something else you anyways get the idea what you want to log.</span></p>
<p><span>In your Episerver log configuration add new appender or ensure that the appender you use allows the debug messages to be writen, here is a demo appender I used to log the messages to a separate file (notice there is no threshold or ranges for log levels configured):</span></p>
<pre class="language-markup"><code><appender name="debugLogAppender" type="log4net.Appender.RollingFileAppender" >
<file value="App_Data\logs\DebugMessages.log" />
<encoding value="utf-8" />
<staticLogFileName value="true"/>
<datePattern value=".yyyyMMdd.'log'" />
<rollingStyle value="Date" />
<appendToFile value="true" />
<layout type="log4net.Layout.PatternLayout">
<conversionPattern value="%date [%thread] %level %logger: %message%n" />
</layout>
</appender></code></pre>
<p>And then we need a logger definition that uses the above appender to actually log the messages (using additivity="false" here so that the messages matching this logger areonly logged here and not passed to other loggers):</p>
<pre class="language-markup"><code><logger name="EPiServer.DataAccess.Internal.ContentSaveDB" additivity="false">
<level value="All" />
<appender-ref ref="debugLogAppender" />
</logger></code></pre>
<p>So next step is to run the the failing job again with the above logging configured and now we get to the log debug messages that tell us the offending content id, like this: "DEBUG EPiServer.DataAccess.Internal.ContentSaveDB: Deleting content 115". So basically the last debug message about "deleting content" before the error in database happens is your offending content id and you can use that content id then to see what content the offending content is (hint: take that id and browse to it in Episerver edit mode, so when in edit mode for example on the site start page modify your browser url and replace the content id in "epi.cms.contentdata:///<strong>5</strong>" with the offending content id value like this "epi.cms.contentdata:///115").</p>
<p>So this way you can find the offending content and try to troubleshoot and understand what has caused the situation and should you actually care or just get rid of the content the "force" way.</p>
<h2>Deleting the offending content</h2>
<p>The first time we faced this issue we contacted Episerver support to get knowledge has this happened in other projects and is there any "supported" way to fix it. This is not common and from Episerver support we just got information that we should edit the 'editDeletePage' stored procedure in the database and set it temporary to use the force delete always (see the @ForceDelete argument in the stored procedure and set it to be 1 always inside the stored procedure) and then run the scheduled job and revert the change to the stored procedure. Naturally there is the disclaimer that you need to test it and take backups if that doesn't work for some reason or causes new issues so you can revert the database to the otherwise working state.</p>
<p>But now that you know what is the offending content id you could skip the stored procedure modifications and instead execute it with the offending content id and call it with @ForceDelete value 1 from SQL Server Management Studio or from command line like this:</p>
<pre class="language-markup"><code>USE [YOUR-DATABASE-NAME-HERE]
GO
DECLARE @return_value Int
EXEC @return_value = [dbo].[editDeletePage]
@PageID = THE-CONTENT-ID-HERE,
@ForceDelete = 1
SELECT @return_value as 'Return Value'
GO</code></pre>
<p>And after executing that you would run the scheduled job again which could still faill because you might have more than one offending content ids but then you would just execute the stored procedure again with the new offending content id.</p>
<p>I hope you never face this same issue but if you do, then you can use the above to fix the situation.</p>2021-03-14T11:07:41.0000000ZBlog postMigrating Episerver content with custom import processing<p>In this blog post I tell you how we solved with custom import processing the customers need to migrate thousand or a bit more pages (plus blocks and media data instances) from one Episerver site to another Episerver site with different content types.</p>
<h3>Background</h3>
<p>First a quick background to understand a bit why and what. Our team had gotten a website lets call it '<strong>Mango</strong>' to maintenance from another Episerver partner and the site building had started around 2014 so there was some history on the implementation of the site and one could clearly see there has been different teams doing the implementation as there seemed to not be one common way how to do things but anyways. So our teams work started with getting the hang of the website implementation and at the same time continue implementing new features and doing some polishing and fixes to it. Months passed and we got a request from the project owner that we would need a new website which is a copy paste of the current website codebase and we need it yesterday ;-)</p>
<p>So naturally we had some discussion with the customer could they tell us more why they need a copy paste of the website and we explained that we shouldn't just copy paste blindly as we would then copy some of the not so good ideas. Also we pointed out that we will have technical dept after this in two sites and not just one. The customer couldn't tell us everything about why they need it and was sad about it at the same time but this copy paste website was supposed to be just temporary, live for 3 months or 6 months at maximum. We would only change fonts and some colors and we would get those soon from a design agency.</p>
<p>Well you can guess it already - the design changes were not just fonts and colors but quite big layout and grid changes compared to copied original layout - and there was the time pressure for the implementation of the "ccopy & paste" website. Anyways the team did it - we did copy paste code base but with modifications, like renaming used content types (namespace changes naturally), use feature folders, refactor configuration and settings, new layouts and styles, etc improvements.</p>
<p>After this "copy & paste" website was ready and testing with real content started, we were told the real reason: there was a merger and now it was official and all legal approval was ready and announced to the public. Our company '<strong>Mango</strong>' merged with another company lets call it '<strong>Orange</strong>' and together they were called '<strong>Mango Orange group</strong>'. So we had created a website for this new company and mainly to contain their new joined corporate pages and financial information. All good.</p>
<p>All of the initial content for this new 'Mango Orange group' website was done manually as the content didn't exist on either 'Mango' or 'Orange' websites but then came the 'but' - it was decided by the new company that this copy & paste website would be the new website and we would need to develop new features there AND migrate existing content from 'Orange' website...</p>
<h3>Content migration options</h3>
<p>If the source websites content types are defined in separate assembly then you could simply reference that assembly in the target website solution and use Episerver built-in export and import functionality with a <strong>BUT</strong>, yes you would have the content types and the import would just work but then you would need to convert the pages, blocks and media types to 'Mango' websites content types which are the ones used. Pages can be converted out of the boxes using the admin tool but that is manual work AND IT DOESN'T convert blocks (or used media data)! Fellow EMVP Tomas Hensrud Gulla has blogged about his custom tool which can covert blocks: <a href="https://blog.novacare.no/convert-episerver-blocks/">Convert Episerver Blocks</a>. So even if we would do all the manual work and convert page types and block types out media data content types still would be incorrect (and in reality we had same content type names with different content guids so we were already screwed on that part) and also it would take time to do it.</p>
<p>My next idea was: What if we could use the Episerver import and hook to the events it exposes and modify the source content in those events to match the destination website content types. Quick proof of concept using two Ally websites with modified content types and different content types gave good results, like we can change the content type in import, we can change properties data type, we can filter out languages we don't have enabled, etc.</p>
<p>So we decided to go with building a custom import processing "framework" to handle the content in the import and convert it to the content types used on our "Mango Orange group" website.</p>
<h3>How does the Episerver import flow works?</h3>
<p>I'll keep this part intentionally on a high level (I'll try to find time to blog about this in more details in future) but on a high level this is how it goes:</p>
<ul>
<li>Episerver import reads the your-export-package.episerverdata package
<ul>
<li>this really is just a zip package (you can open it for example with 7-zip) and look at the structure
<ul>
<li>inside there is folder 'epi.fx.blob:' which child folder contains the exported blobs</li>
<li>in the root there is the epix.xml
<ul>
<li>xml file containing the exported content (basically pages and blocks with content language versions)</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
<li>and the import framework is triggered with the data from your package</li>
<li>first the blobs are imported
<ul>
<li>this is the binary part of the blobs, so files are copied to your target blobs container</li>
<li>in the event handling you can inspect the blobs filename for example for allowed extension and cancel the import for the blob if the file extension is not allowed in the target website</li>
</ul>
</li>
<li>next step is to import the content
<ul>
<li>here you can inspect the content to be imported, you get all the data about the content to be imported (<strong>Note!</strong> The event handler gets a single item when it is called and it doesn't know about other content)
<ul>
<li>add or remove properties</li>
<li>rename properties</li>
<li>change propertys data type (like from Episerver Url to ContentReference, naturally only when the url was pointing to Episerver content)</li>
<li>you have full control to the content type about to be imported, so can do quite many things to the data at this stage</li>
<li>cancel the import of the content</li>
<li>change should the 'For All Sites' be used instead of 'For This Site' (for example if images are not stored with the content 'For This Page' or 'For This Block' but in a shared location)</li>
<li>check that the master language is enabled in the target website</li>
<li>remove language branches that the target doesn't support</li>
</ul>
</li>
<li>after your code has processed the content and has not canceled the content import
<ul>
<li>Episerver default import implementation creates the content type instance basically using the content repository <strong>GetDefault</strong> using the content type id and content master language
<ul>
<li><strong>Note</strong>, when Episerver is resolving the content type to create it has some fallback logic <strong>if the content to be created was not found using the content type id</strong> (property: PageTypeId)
<ul>
<li>try to load the content type using the content type name (property: PageTypeName)</li>
<li>try to load the content type using the ContentTypesMap</li>
<li>try to load the content type using the content types display name</li>
</ul>
</li>
</ul>
</li>
<li>after the instance is created using IContentRepository.GetDefault method it reads the property values for the master language of the content and triggers the property import event
<ul>
<li>most likely you don't do anything else than debug log the values here as you have most likely processed the property values already in the import content event handler</li>
<li>and then Episerver import sets the instances property value to the property value from the import process</li>
</ul>
</li>
<li>and then the same for language branches if there were any</li>
</ul>
</li>
</ul>
</li>
<li>import done</li>
</ul>
<p><strong>Note!</strong> When importing content to the target site you most likely should keep the "Update existing content items with matching ID" checkbox checked. Why? This also makes the import keep the same content id for the content which you will need if you are not doing the whole import for all content in one go (most likely you will do multiple imports to keep the import package size smaller and to do the migration in parts), this way your content links don't break when doing multiple import batches as Episerver uses the original content ids so the links between content keeps working because of that). There is also one cool feature or side-effect of having it checked - you could later also import a single language branch for the content from the original source and it would be connected to the already imported content because same content ids were used in target and source. </p>
<h2>Building the custom import processing</h2>
<p>Building blocks for our custom import processing:</p>
<ul>
<li>custom initializable module that hooks to the import events
<ul>
<li><a href="/link/e8ee864338d24e89b67f0325cc0fbaa1.aspx">creating initialization module</a> Episerver documentation</li>
<li>import events <a href="/csclasslibraries/cms/EPiServer.Enterprise.IDataImportEvents?version=11">IDataImportEvents</a> (assembly: EPiServer.Enterprise, namespace: EPiServer.Enterprise)</li>
<li>is the entry point for the whole import process</li>
<li>finds the import content type processor which can handle the content and calls it with the content properties
<ul>
<li>handles language branches also, so if the langugae branch is not supported in the target it will remove the language branch properties</li>
</ul>
</li>
<li>handles should a blob be imported or not (based on the blobs file extension)</li>
<li>knows about the target enabled languages
<ul>
<li>will cancel import for content which is not in the enabled languages</li>
</ul>
</li>
<li>if content uses 'For This Site' folder then that is switched to 'For All Sites'</li>
</ul>
</li>
<li>custom interface for content processors: IImportContentTypeProcessor
<ul>
<li>the implementation is responsible to process the content
<ul>
<li>modify the content to match the target system</li>
</ul>
</li>
<li>has a method: bool CanHandle(string contentTypeId);
<ul>
<li>guid string for content type like: 9FD1C860-7183-4122-8CD4-FF4C55E096F9</li>
<li>called by our initialization module when import raises the ContentImporting event to find a processor that can handle the content</li>
</ul>
</li>
<li>has a methd: bool ProcessMasterLanguageProperties(Dictionary<string, RawProperty> rawProperties);</li>
<li>has a method: bool ProcessLanguageBranchProperties(Dictionary<string, RawProperty> rawProperties);</li>
<li>(initially I thought we might need language branch specific processing but it turned out there was no need for that method)</li>
<li>the used Dictionary<string, RawProperty> rawProperties is just to avoid looking up properties multiple times from the ContentImportingEventArgs e e.TransferContentData.RawContentData.Property RawProperty array => read the array to a dictionary where the key is the property name and value is propertys RawProperty data</li>
</ul>
</li>
</ul>
<h3>Import handler initialization module implementation</h3>
<p>So create a new initialization module using the Episerver documentation: <a href="/link/e8ee864338d24e89b67f0325cc0fbaa1.aspx">creating initialization module</a>.</p>
<p>And in the initialize method get a reference to IDataImportEvents and to the ILanguageBranchRepository services. We store the ILanguageBranchRepository to the initialization modules private field for later use. So out Initialize method implementation looks like this:</p>
<pre class="language-csharp"><code>public void Initialize(InitializationEngine context)
{
try
{
if (context.HostType == HostType.WebApplication)
{
var locator = context.Locate.Advanced;
// import events
var events = locator.GetInstance<IDataImportEvents>();
// language branch repository
_languageBranchRepository = locator.GetInstance<ILanguageBranchRepository>();
if (events != null && _languageBranchRepository != null)
{
// Register the processors
RegisterImportContentTypeProcessors();
if (_importContentTypeProcessors.Count == 0)
{
ContentMigrationLogger.Logger.Warning("There are no import content type processors registered. Disabling import migration handling.");
// pointless to register to import events if we have no processors
return;
}
// subscribe to import events
events.BlobImporting += EventBlobImporting;
events.BlobImported += EventBlobImported;
events.ContentImporting += EventContentImporting;
events.ContentImported += EventContentImported;
events.PropertyImporting += EventPropertyImporting;
events.Starting += EventImportStarting;
events.Completed += EventImportCompleted;
// we have registered events handlers which we should unregister in uninitialize
_eventsInitialized = true;
}
else
{
ContentMigrationLogger.Logger.Error($"Import migration handling not enabled because required services are not available. IDataImportEvents is null: {events == null}. ILanguageBranchRepository is null: {_languageBranchRepository == null}.");
}
}
}
catch (Exception ex)
{
ContentMigrationLogger.Logger.Error("There was an unexpected error during import handler initialization.", ex);
}
}</code></pre>
<p><strong>NOTE!</strong> The method RegisterImportContentTypeProcessors() is in the initialization module and is used to register the IImportContentTypeProcessor services and stored to initialization modules private field for later use. ContentMigrationLogger is just our own static class that contains the shared logger for all import logging activities. The events BlobImported and ContentImported are only used to write debug messages about the content to be able to troubleshoot issue related to the content (mainly used when developing an implementation for IImportContentTypeProcessor and testing locally with content).</p>
<h4>Blob import</h4>
<p>So as I mentioned previously that blobs are the first thing the import processes, our blob importing handler looks like this:</p>
<pre class="language-csharp"><code>private static readonly string[] _allowedFileExtensions = new string[] { "mp4", "jpg", "jpeg", "png", "svg", "pdf", "json" };
private void EventBlobImporting(EPiServer.Enterprise.Transfer.ITransferContext transferContext, FileImportingEventArgs e)
{
if (e == null)
{
ContentMigrationLogger.Logger.Error("EventBlobImporting called with null reference for FileImportingEventArgs.");
}
if (ContentMigrationLogger.IsDebugEnabled)
{
ContentMigrationLogger.Logger.Debug($"Importing blob, provider name '{e.ProviderName}', relative path '{e.ProviderRelativePath}' and permanent link virtual path '{e.PermanentLinkVirtualPath}'.");
}
// try to get the file extension
if (e.TryGetFileExtension(out string fileExtension))
{
// check is the extension allowed/supported
if (!_allowedFileExtensions.Contains(fileExtension, StringComparer.OrdinalIgnoreCase))
{
ContentMigrationLogger.Logger.Error($"Cancelling blob import because the file extension '{fileExtension}' is not allowed. Provider name '{e.ProviderName}', relative path '{e.ProviderRelativePath}' and permanent link virtual path '{e.PermanentLinkVirtualPath}'.");
e.Cancel = true;
}
}
else
{
// no file extension or it could not be resolved, cancel the blob import
ContentMigrationLogger.Logger.Error($"Cancelling blob import because the file extension could not be extracted from provider relative path value '{e.ProviderRelativePath}'.");
e.Cancel = true;
}
}</code></pre>
<p>And here are a snip from our extensions and helpers class for the used extension: TryGetFileExtension(out string fileExtension)</p>
<pre class="language-csharp"><code>/// <summary>
/// Gets the file extension from a file name (or path and filename).
/// </summary>
/// <param name="fileName">file name or path and file name</param>
/// <param name="fileExtension">the file extension extracted from the <paramref name="fileName"/> without the dot, so result will be like: jpg or png etc.</param>
/// <returns>True if file extension was extracted from <paramref name="fileName"/> otherwise false</returns>
/// <remarks>
/// <para>
/// The extension is not normalized (nothing is done to capitalization), meaning if the extension is 'PnG' then that will be returned.
/// </para>
/// </remarks>
private static bool GetFileExtension(string fileName, out string fileExtension)
{
fileExtension = null;
if (!string.IsNullOrWhiteSpace(fileName))
{
try
{
string tmpFileExtension = Path.GetExtension(fileName);
if (!string.IsNullOrWhiteSpace(tmpFileExtension) && tmpFileExtension.Length >= 2)
{
// length check so that there is more than the dot
fileExtension = tmpFileExtension.Substring(1);
return true;
}
}
catch (Exception ex)
{
ContentMigrationLogger.Logger.Error($"Gettting file extension from filename '{fileName}' failed.", ex);
return false;
}
}
return false;
}
/// <summary>
/// Tries to get the file extension from FileImportingEventArgs property ProviderRelativePath value.
/// </summary>
/// <param name="args">Instance of <see cref="EPiServer.Enterprise.FileImportingEventArgs"/> or null</param>
/// <param name="fileExtension">Extracted file extension</param>
/// <returns>True if the file extension was extracted otherwise false</returns>
public static bool TryGetFileExtension(this EPiServer.Enterprise.FileImportingEventArgs args, out string fileExtension)
{
fileExtension = null;
if (args == null)
{
return false;
}
if (GetFileExtension(args.ProviderRelativePath, out fileExtension))
{
return true;
}
return false;
}</code></pre>
<h4>Content import</h4>
<p>Next step in the import process is to import the actual content and this is the place where we can do manipulation to the content and or cancel the import totally for the content. Episerver import process triggers the ContentImporting event per each content item that is about to be imported (so this event happens before the content item is actually created).</p>
<p>Here is a picture about the epix.xml file structure (the actual xml file was modified, entries removed so that I could squeeze the entries to the picture), showing that there is master language content in english and then there is language branch content in finnish:</p>
<p><img src="/link/47196f840c27403fbd377b2879fc1ed1.aspx" /></p>
<p>So from the picture you can see the basic structure of the XML:</p>
<ul>
<li>pages element will contain TransferContentData element(s)
<ul>
<li>TransferContentData is the single content item and its language versions (and other possible settings, like language fallback settings in ContentLanguageSettings element)
<ul>
<li>if the RawContentData has type attribute with value RawPage, then the content is a page, otherwise its some other content type like: block, media, etc</li>
<li>RawContentData holds the master content property values</li>
<li>Language branch property values are in the RawLanguageData</li>
<li>structure is the same for both the RawContentData and RawLanguageData
<ul>
<li>so below those we have the ACL element that can hold access-control settings</li>
<li>Property element holds all properties for the content
<ul>
<li>there is a RawProperty per each property on the content type, and these hold all information about each property, like type, typename, is language specific, etc</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
<p>epix XML file high level structure:</p>
<p><img src="/link/3c91f0d2481b46559c9a7dacaae9d2e3.aspx" /></p>
<p>So back to the importing event, this event is where we get the TransferContentData element with children nicely parsed to corresponding .Net framework objects. We can get the content from <a href="/csclasslibraries/cms/EPiServer.Enterprise.ContentImportingEventArgs?version=11">ContentImportingEventArgs</a> TransferContentData property which is of type <a href="/csclasslibraries/cms/EPiServer.Core.Transfer.ITransferContentData?version=11">ITransferContentData</a> and that interface defines the properties which will hold the data from the epix.xml file. So this is the place where "fun" starts with the data manipulation. Unfortunately I cannot share all the code we've writen for the custom import processing but I'll try to share enough information and code snips that might be enough to get you in good start in your own project.</p>
<p>For example in our content the source content had language fallbacks defined in sub structure of the website and we didn't want to bring in any of those settings to our target site, so we created a simple extension method that always removes that information from content:</p>
<pre class="language-csharp"><code>/// <summary>
/// Removes all content language settings from the <see cref="ITransferContentData.ContentLanguageSettings"/>.
/// </summary>
/// <param name="transferContentData">Instance of <see cref="ITransferContentData"/> or null</param>
public static void RemoveContentLanguageSettings(this ITransferContentData transferContentData)
{
if (transferContentData != null && transferContentData.ContentLanguageSettings != null)
{
transferContentData.ContentLanguageSettings.Clear();
}
}
// transferContentData is gotten from the ContentImportingEventArgs e,
// var transferContentData = e?.TransferContentData;
// transferContentData.RemoveContentLanguageSettings();</code></pre>
<p>Then we also use an extension method with some overload extension methods which we can use to once load the RawProperty items to a dictionary where key is the property name and value is the original RawProperty instance. This way we get faster lookups for the properties we want to get instead enumerating the RawProperty[] containing the properties each time we need to do something about a property in the processing. Below is sample code for such extension:</p>
<pre class="language-csharp"><code>/// <summary>
/// Reads the properties to a dictionary where key is the property name and value is the original RawProperty.
/// </summary>
/// <param name="rawProperties">Array of RawProperty instances</param>
/// <returns>Dictionary containing the original properties</returns>
/// <remarks>
/// <para>
/// NOTE! The RawProperty instances are not copied from the origin they still point to the original array
/// so any modifications are done to the original properties.
/// </para>
/// </remarks>
public static Dictionary<string, RawProperty> GetRawPropertiesAsDictionary(this RawProperty[] rawProperties)
{
if (rawProperties == null || rawProperties.Length == 0)
{
return new Dictionary<string, RawProperty>(0);
}
var dict = new Dictionary<string, RawProperty>(rawProperties.Length);
foreach (var property in rawProperties)
{
// if there is a null value in the array then skip it
if (property == null)
{
continue;
}
dict.Add(property.Name, property);
}
return dict;
}</code></pre>
<p>NOTE! As said in the above code comments, the dictionary value objects are still pointing to the same original objects held in the source array, so any changes you make using the dictionary are actually done to the source array objects too, keep this in mind! In our implementation the idea is not to care about the changes to the original array as we will always overwrite the original array objects in our code by calling a Save extension method like this:</p>
<pre class="language-csharp"><code>/// <summary>
/// Writes the <paramref name="rawProperties"/> dictonary 'Values' property to <paramref name="content"/> instances 'Property' field.
/// </summary>
/// <param name="content">Instance of RawContent</param>
/// <param name="rawProperties">Dictionary containing the raw properties to be writen to the <paramref name="content"/> instances Property field.</param>
/// <exception cref="ArgumentNullException"><paramref name="content"/> is null</exception>
/// <remarks>
/// <para>
/// You need to call this method so that all your changes like removing property gets persisted to the RawContent (<paramref name="content"/>) instances Property field.
/// </para>
/// <para>
/// If the <paramref name="rawProperties"/> is null or has no entries then nothing is done. If your intention is to remove all properties then you need to do it other way.
/// </para>
/// </remarks>
public static void Save(this RawContent content, Dictionary<string, RawProperty> rawProperties)
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
if (rawProperties.HasEntries())
{
content.Property = rawProperties.Values.ToArray();
}
}</code></pre>
<p>And we have similiar Save method for block properties (cases where a local block is used aka Block as a property).</p>
<p>Here is a link to a gist containing some extension methods to get Episerver known properties from the "rawproperties" dictionary: <a href="https://gist.github.com/alasvant/c446b68cda607ab734110af73aef317b">https://gist.github.com/alasvant/c446b68cda607ab734110af73aef317b</a></p>
<h4>Import flow in our implementation</h4>
<p>So instead copy pasting all of our projects code here, instead I will describe our flow:</p>
<ul>
<li>remove the previously mentioned content language settings</li>
<li>parse the content propeties to dictionary</li>
<li>get the content 'content type id' property value from dictionary
<ul>
<li>if there is no content type id, do nothing about the content (let Episerver import decide what to do about it)</li>
</ul>
</li>
<li>find a content type processor using the content type id from the registered content type processors
<ul>
<li>note, in our implementation a content type processor can handle a single or many content types, that's why it has the CanHandle(string) method defined in the interface</li>
<li>first processor saying it can handle the content is used</li>
<li>if not content type processor is found, we check the content master language that it is enabled in the system
<ul>
<li>if the master language is not enabled, we cancel the import for the content as the Episerver import would otherwise error on the content and break the import process</li>
</ul>
</li>
</ul>
</li>
<li>if a processor was found, we call its ProcessMasterLanguageProperties method with the master language properties
<ul>
<li>if the processor returns true, so the content was processed without errors, we save the modified properties to RawContentData property (event argument e.TransferContentData.RawContentData)
<ul>
<li>and then we have code that loops the e.TransferContentData.RawLanguageData (list containing the language branches)
<ul>
<li>check that the language is enabled in the system, if not - add the language to "to be removed list"</li>
<li>pass the parsed language properties to ProcessLanguageBranchProperties method in the processor
<ul>
<li>if the method returns true, save the properties to the original object (RawContent.Property whihc is RawProperty array, so we basically call for the dictionary: content.Property = rawProperties.Values.ToArray();)</li>
<li>if the method returns false, then add the language to "to be removed list"</li>
</ul>
</li>
<li>finally, if there are any entries in the "to be removed list", we remove those languages from the original list</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
<h4>Content manipulation</h4>
<p>So what can we do about the content:</p>
<ul>
<li>we can cancel the content import by setting the e.Cancel = true, in the event handler for the ContentImportingEventArgs instance</li>
<li>we can change the content type id
<ul>
<li>for example, let's say that you have copied (like copy paste source code) from site A to site B, but you have changed the content type id and the class name and now you would like to import some instance from site A to site B</li>
<li>if all the properties are still the same, it is enough just to change the content type id value in the import to match the target system content id</li>
</ul>
</li>
<li>we can remove properties, simply in the code remove the property from the rawDictionary (referring our processing implementation)</li>
<li>we can rename properties, simply get the property using the source property name and change the referenced RawProperty objects property name</li>
<li>we can convert property types (with some limitations, you need to be able to write the code to do the conversion)
<ul>
<li>for example in our case, we had used <a href="/csclasslibraries/cms/EPiServer.Url?version=11">Episerver Url</a> type for a property and in the destination we had changed it to ContentReference as the properties were used for example for image so there was no need for it to be Url
<ul>
<li>so we have created a helper method which tries to convert source Url to a ContentReference<br />
<ul>
<li>the source value is like this in the RawProperty value (string): ~/link/653ebc1fa8184dbdbab2023e3998ce28.aspx</li>
<li>code extracts the "guid" string from the source, so it grabs the value: 653ebc1fa8184dbdbab2023e3998ce28</li>
<li>and then creates a new string with the following format: [653ebc1fa8184dbdbab2023e3998ce28][][]
<ul>
<li>thats how ContentReference is serialized to the epix.xml, so we a re just mimicin that, NOTE! There can be also language information but we are leaving those empty in our case</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
<li>we can re-map the content to a totally different content type
<ul>
<li>so basically change the content type id</li>
<li>rename properties</li>
<li>remove properties</li>
<li>add new properties and copy values to it from multiple properties
<ul>
<li>for example when target uses a local block (block as a property) and the source have the values in multiple properties</li>
</ul>
</li>
</ul>
</li>
<li>you can change the contents publishing status
<ul>
<li>for example in our code we have blocks published but pages are changed to draft</li>
</ul>
</li>
<li>you could add new language branches in your code</li>
<li>you could change content master language
<ul>
<li>for example if all content should be created in english and your source content has content created in Finnish as the master language and there is English language branch, then in your code you could switch the master language properties vice versa with tha language branch </li>
</ul>
</li>
</ul>
<p>What we can't do?</p>
<ul>
<li>add totally new content that doesn't exist in the import data, meaning you just can't create a new additional page for example, because everything is based on the import data<br />
<ul>
<li>well you might be able to do some hacks like storing information about some content during the import process and after import have something else be triggered to create the extra content</li>
</ul>
</li>
</ul>
<h4>Property import</h4>
<p>Last step in the import is the PropertyImporting event which we basically used only for debug logging in development (property information, what is about to be imported).</p>
<h2>Closing words</h2>
<p>This time a bit less code than usually in my posts but I simply can't copy paste the code from the project :D Hopefully this post though gives you some ideas if you find your self in a situation that you need to find a way how migrate a lot of content from site or sites to another site - you might maybe be able to import some if not all content using a custom import processing implementation and cut the costs in the migration project.</p>
<p>I make no promise but I might later add a new post with a working sample code with two Alloy sites - but as we all know that Episerver .Net Core is coming, so depending when it is officially released might change my priorities :D</p>
<p>Please feel free to ask questions in the comments section if something was left unclear or needs more information and I will try to answer.</p>2021-01-23T13:15:45.0000000ZBlog postExport selected languages<p>Ever needed the functionality to just export the selected languages in Episerver instead of all languages which is the default behavior? If Yes, then this post is for you.</p>
<h2>Background</h2>
<p>Little background for the post and small <a href="https://nuget.episerver.com/package/?id=Swapcode.EpiExport.LanguagesSelector">add-on</a> I've added to Episerver NuGet feed. I'm working on a project where we are going to migrate thousands of pages from old site to a new site. There are just few buts.. our source site uses tens of languages where usually master language is English but there are some single pages here and there where the master language is not english. Our destination has just two languages enabled. So when we export content from source site even small selected sections for export can grow to huge export packages like the worst ones are 1GB! So if we could only define which languages to export we could cut down the size of the export package.</p>
<p>We've built an import pocessing 'framework' in the destination site that manipulates the content in import as we have different content types in the target site (solution). Also if there are unsupported languages in the content we discard those versions (master or language branch). Also the processing can transform content types from source to destination content types - so when we do import there are zero warnings :) Our import processing utilizes the <a href="/csclasslibraries/cms/EPiServer.Enterprise.IDataImportEvents?version=11">EPiServer.Enterprise.IDataImportEvents</a> and does the magic there. Have to say I'm happy how well it has worked but that was not the point of this blog post but the export languages, maybe more about the export / import migration in another post :D</p>
<h2>Export</h2>
<p>Episerver exposes events during the export which we can hook to, see the <a href="/csclasslibraries/cms/EPiServer.Enterprise.IDataExportEvents?version=11">EPiServer.Enterprise.IDataExportEvents</a>. So I wanted to know if I hook up to the <a href="/csclasslibraries/cms/EPiServer.Enterprise.IDataExportEvents?version=11#EPiServer_Enterprise_IDataExportEvents_Starting">Starting event</a> could I say to the export that it should only export the languages I supply to it. And yes it is possible to supply a list of languages for the export (see the <a href="https://github.com/alasvant/Swapcode.EpiExport.LanguagesSelector/blob/master/src/Swapcode.EpiExport.LanguagesSelector/ExportLanguagesInitializationModule.cs">code in my repo</a>) so in the Starting event of export we get <a href="/csclasslibraries/cms/EPiServer.Enterprise.Transfer.ITransferContext?version=11">ITransferContext</a> which inherits <a href="/csclasslibraries/cms/EPiServer.Core.Transfer.IContentTransferContext?version=11#EPiServer_Core_Transfer_IContentTransferContext_ContentLanguages">ContentLanguages</a> property from IContentTransferContext which is a list of languages. If no languages are supplied then all languages are exported and the language value in the list is any valid culture name like 'en' or 'fi' (see <a href="https://docs.microsoft.com/en-us/dotnet/api/system.globalization.cultureinfo.getcultureinfo?view=netframework-4.6.1#System_Globalization_CultureInfo_GetCultureInfo_System_String_">CultureInfo.GetCultureInfo(string)</a>).</p>
<p>After the POC we needed a way to be able to configure the languages - hard coding the values to the event was not an option because we still should be able to export all languages for example if we need to move small amount of data from production to test or development environment. So for that I utilized the old but still working <a href="/csclasslibraries/cms/EPiServer.PlugIn.GuiPlugInAttribute?version=11">GuiPlugIn</a> and <a href="/csclasslibraries/cms/EPiServer.PlugIn.PlugInPropertyAttribute?version=11">PlugInProperty</a> attributes together with <a href="/csclasslibraries/cms/EPiServer.PlugIn.PlugInSettings?version=11">PlugInSettings</a> to persist and load the configured settings.</p>
<h2>Configuration</h2>
<p>Export languages configuration is done from Admin views 'Config' tab and using the Plug-in Manager.</p>
<ul>
<li>click the 'Swapcode.EpiExport.LanguagesSelector'</li>
</ul>
<p><img src="/link/7deccf17b1b1422bbae3e425250766ce.aspx" /></p>
<ul>
<li>next you will be shown a list of checkboxes of the languages enabled in your system</li>
<li>select the languages you want to include to the export and click save</li>
</ul>
<p><img src="/link/ee0f4e4d3efd46ed9db0baa452e0d59a.aspx" /></p>
<p>Just remember to uncheck the checkboxes after your export and save that Episerver default export functionality is used again.</p>
<h2>What it does not do?</h2>
<p>It just sets the languages but this does actually mean language branches - so for example you have a page created in English (master language) and then you have translated that page to three other languages like Finnish, Swedish and Latvian. If you now set in settings that English and Finnish languages are used in export you will only get the en and fi languages to the export package.</p>
<p>Lets take the example one step further and add pages under the above sample pages but create each page in differen language (so master language is not en but some other language for each page), something like this:</p>
<p> <img src="/link/328b07227ec44602b26354fdea4eb202.aspx" /></p>
<p>Now if you export the 'Group masterlanguages' and have the export setting 'Include sub items' selected You most likely would expect the export to only contain the container and the 'en' and 'fi' pages but you will actually have all the pages in this case - this is Episerver export defaul behavior, it includes all master language versions as those have the not culture specific values.</p>
<p>The same will be true for blocks (or any other localizable content) - so cases like if you have blocks in the 'For This Page' assets folder all languages are exported even when you have specified that only certain languages should be exported.</p>
<p>So remember the above if using this add-on (at least for the initial version 1.0.0).</p>
<p>I did try to exclude content in the <a href="/csclasslibraries/cms/EPiServer.Enterprise.IDataExportEvents?version=11#EPiServer_Enterprise_IDataExportEvents_ContentExporting">ContentExporting</a> event using the selected languages but when I removed content in export the generated export package failed to import. There was an XML Element error during import (maybe I will write something in another blog post about the Episerver *.episerverdata export package ;-) ), I do know where the error is in the XML file in theory but import is reading the XML file in parts and the line number is not true when looking at the whole XML file and in my case that XML file was 25MB and I didn't have time to start splitting it and investigate it as in our import processing "framework" we are already handling not supported languages (not enabled languages) so it was not that big issue for us other than we couldn't make the package even smaller.</p>
<h2>NuGet package and sources in GitHub</h2>
<p>Sources are in GitHub: <a href="https://github.com/alasvant/Swapcode.EpiExport.LanguagesSelector">https://github.com/alasvant/Swapcode.EpiExport.LanguagesSelector</a></p>
<p>NuGet package is in Episerver NuGet feed: <a href="https://nuget.episerver.com/package/?id=Swapcode.EpiExport.LanguagesSelector">https://nuget.episerver.com/package/?id=Swapcode.EpiExport.LanguagesSelector</a></p>
<p>In our project we have already added additional filtering to the export and I will most likely add that soonish to this package (but then it is no longer just about languages, so the add-on naming no longer is correct :D).</p>
<p>I will also try to look in the issue about excluding content in the ContentExporting event and what causes the import to fail - it could be the data or a bug in the export.</p>2020-11-25T18:08:56.0000000ZBlog postHow to protect you public test or stage environment from outsiders using authorization?<p>Sometimes we face a situation that we can't use maybe the more common/better ways to protect the test/stage environment by using IP-restrictions in <strong>web[dot]config</strong> (fyi, the blog platforms cloudflare security feature prevents using the dot in the file name :D) or in a load balancer or in a Web Application Firewall (WAF) or in a firewall or some other security feature. So is there then no other way? Yes there is - well at least we can make the resources not availabe if the user can't login in.</p>
<p>Background:</p>
<ul>
<li>we havea public facing test and stage environment</li>
<li>we have people from all over the world with dynamic IP-addresses who should be able to see the content
<ul>
<li>they all have logins and different roles setup</li>
<li>ASP.NET Identity is used</li>
</ul>
</li>
<li>we don't want "outsiders" to be able to see any resources from the website</li>
<li>excluding login and logout pages, these should be naturally accessible for anonymous users ;)</li>
</ul>
<h2>Solution one</h2>
<p>Use Episerver 'Set Access Rights' and remove the 'Read' access from 'Everyone' group.</p>
<p>Pros:</p>
<ul>
<li>can be done from Episerver Admin UI</li>
</ul>
<p>Cons:</p>
<ul>
<li>depending how access rights are used on the site, might require quite some clicking in the content tree to find all nodes which are not inheriting access rights from root</li>
<li>does not affect any static resources</li>
<li>does not affect any dynamic resources / programmatic resources not having authorization</li>
<li>when content is refreshed from production, this needs to be done again</li>
</ul>
<h2>Solution two</h2>
<p>Use IIS security in web[dot]config file.</p>
<p>Pros:</p>
<ul>
<li>can be done with a simple configuration transform for the target environment</li>
<li>content can be refreshed and no actions are needed, same restrictions are still in place</li>
<li>we can protect all resources from the website</li>
<li>well excluding the login and logout pages</li>
<li>no need to change the existing access rights for the content in Episerver</li>
</ul>
<p>Cons:</p>
<p>None - Just kidding :D</p>
<ul>
<li>it will not totally block access to the website for anonymous users, the login and logout pages are exposed</li>
<li>actually my below condifuration exposes anything below util path</li>
<li>because it will redirect to login when user is not logged in, if Episerver default login is used, it will expose the fact that the website is done with Episerver to the world
<ul>
<li>usually this is acceptable</li>
</ul>
</li>
</ul>
<h3>web[dot]config configuration sample</h3>
<p>So how to configure? Find in your web[dot]config file the root 'system.webServer' section and add the following or modify your existing element.</p>
<pre class="language-markup"><code><security>
<authorization>
<!-- remove any exising users and roles -->
<remove users="*" roles="" verbs=""/>
<!-- add the roles that should be allowed to use the website after authentication -->
<!-- now using the Episerver default groups which you need to change if you use something else -->
<add accessType="Allow" users="" roles="WebAdmins,WebEditors"/>
</authorization>
</security></code></pre>
<p>So the above will allow the selected groups/roles to access the website and if the request is not authorized the user will be redirected to the configured login url.</p>
<p>The above configuration blocks all requests so we need to allow anonymous requests (or requests that don't have the required roles to access the login page), so we need to add another configuration.</p>
<p>In your web[dot]config file find the location element for your login path (or add it if you are not using Episerver default login page). So the following configuration assumes you are using the default path which is under the 'util' path (if you have moved the util path to your-secret-util-path then you would apply the following change to that location element). Find the location element with path="util" and modify its system.webServer section.</p>
<p>Note! This is needed because we are not using Forms authentication but ASP.NET Identity, the authorization element has attribute 'bypassLoginPages' which defaults to true and would skip authorization for the loging page when using Forms authentication.</p>
<pre class="language-markup"><code><security>
<authorization>
<!-- remove any previous configurations -->
<remove roles="" users="*" verbs=""/>
<!-- allow anonymous users -->
<!-- and allow get and post verbs only -->
<!-- get the page and post the login form -->
<add accessType="Allow" users="*" roles="*" verbs="GET,POST"/>
</authorization>
</security></code></pre>
<p>So after the above configurations the website should beonly accessible for 'authorized' users - so users who have logged in and have WebAdmins and/or WebEditors roles.</p>
<p>Tip! If you look at the login page request in browser developer tools network tab you will notice that there are some requests that have ended with 302 redirect to the login page. The login page works even without these resources and there seems to be no visible artifacts or missing functionality BUT if you want those requests to succeed you need to add two more location elements with allow configuration.</p>
<p>On the login page there are three requests to WebResource.axd and two requests to CSS style files under App_Themes/Default/Styles, so we can also allow those if we want to.</p>
<p>Add the following location elements to your web[dot]config file.</p>
<pre class="language-markup"><code><!-- allow anonymous users to get the resources requested on util/login.aspx and logout.aspx-->
<location path="WebResource.axd">
<system.webServer>
<security>
<authorization>
<remove roles="" users="*" verbs=""/>
<add accessType="Allow" users="*" roles="*" verbs="GET"/>
</authorization>
</security>
</system.webServer>
</location>
<!-- allow anonymous users to get styles -->
<location path="App_Themes/Default/Styles">
<system.webServer>
<security>
<authorization>
<remove roles="" users="*" verbs=""/>
<add accessType="Allow" users="*" roles="*" verbs="GET"/>
</authorization>
</security>
</system.webServer>
</location></code></pre>
<p>All done!</p>
<p>Note, you should be able to also use the "system.web" section for the configuration but that is basically for old IIS and old Cassini development server ;)</p>
<p>See the <a href="https://docs.microsoft.com/en-us/iis/configuration/system.webserver/security/authorization/#configuration">IIS configuration reference for authorization</a>.</p>2020-11-10T18:34:46.0000000ZBlog postHow to blog on Episerver World?<p>In this post I will show you how to blog to Episerver World and contribute to the community. Some seasoned developers already know how to blog and might wonder what is the point of the post? In a nutshell there are two options: aggregate your blog feed from external system or use the Episerver World blog platform. But keep on reading, you might not have used the Episerver World blog platform and the codumentation about it is simply non-existant (or I really couldn't find it :D) - there is a <a href="/link/9a1302979f4e4e118306b1054f51bc3c.aspx">really old instruction</a> that speaks about using Microsoft/Windows Live Writer which has been discontinued for quite some time.</p>
<h2>Background</h2>
<p>I've been using the free <a href="https://wordpress.com">wordpress.com</a> blogging platform for quite some time. For free you get the wordpress platform and custom cname-host (with https) like <a href="https://swapcode.wordpress.com/">swapcode.wordpress.com</a> that I have been using for my blog so far. In that service you get a limited amount of free templates where to choose how your site looks like and you can change the template when you so choose. The platform includes commenting and spam filtering but users naturally need to have a wordpress account to be able to comment, someone might have a good comment but the choose not to register with wordpress just to be able to comment. The built-in comment filtering is really needed - usually there is one real comment and 40 spam comments, so you need to also manage the comments and allow the real comments to be visible on the site.</p>
<p>So I've been pretty happy with the wordpress platform but never really been happy with the templates because most of them seem to have have something that annoys me or I would like them to work a bit differently. Yes, I oculd pay for the service and get my own fancy domain and have my own templates but really, I don't have time for that. I need something out of the box that I can live with.</p>
<p>So that is the 'why', why I decided that I would give the Episerver World blog platform a try - most likely it has everything I need and as a bonus there is the rating system, getting anonymous feedback on the post quality/usefulness.</p>
<h2>Aggregating blog feed</h2>
<p>If you use aggregating your blog feed to Episerver World then you simply navigate to your profile settings page</p>
<ul>
<li>go to 'Account Settings' tab</li>
<li>add your Atom/RSS feed url like: <a href="https://swapcode.wordpress.com/feed/">https://swapcode.wordpress.com/feed/</a>
<ul>
<li>optionally add some tags to filter what blog posts are aggregated to Episerver World</li>
</ul>
</li>
<li> and click 'Save' button</li>
</ul>
<p>(disclaimer! I can't remember anymore if you initially have to use the '<a href="/link/1883e72de62e4947b1e9f57a841b088c.aspx">Create Blog</a>' page to get your feed added)</p>
<h2>Blogging using the Episerver World platform</h2>
<p>To get started, first you have to have an account at Episerver World (same applies to aggregated feed) and if you are working with Episerver you really already have the account but if not, why not register an account even if you are not starting to blog right away ;)</p>
<p>From the Episerver World Blogs page there is a link at the top '<a href="/link/1883e72de62e4947b1e9f57a841b088c.aspx">Start blogging - create your own blog</a>' so click that link to create Your new shiny Episerver World Blog.</p>
<p><img src="/link/fc5b31520ed947ccb0ac126276cf00d2.aspx" /></p>
<p>Read, understand, check 'I Accept' checkbox and click Submit button. Easy.</p>
<p><strong>Note!</strong> <span style="text-decoration: underline;">If you have already created an aggregated blog</span> then you will not need to do this step as Your blog already exists. You can directly navigate to the '<a href="/link/5e37b120db614d1b8287a3b664f1a9ac.aspx">Manage your blog posts on Episerver World</a>' page.</p>
<h2>Your first blog post</h2>
<p>Ready, set,Go! Writing your first blog post. You create and manage the blog post from the "<a href="/link/5e37b120db614d1b8287a3b664f1a9ac.aspx">Manage your blog posts on Episerver World</a>" page, you can find the link from the <a href="/link/bccc323fc15e45259d7a934d1efb5d52.aspx">Blogs</a> front page. <strong>@Episerver world team</strong>, if the user is logged in and has blogs enabled then could the Episerver World 'Blogs' main nvaigation have a child 'Manage blogs' entry?</p>
<p><img src="/link/8834095c4ec6477497f00dfa9fbe06cd.aspx" width="980" alt="Manage Your blog posts or create a new" height="592" /></p>
<p>(<strong>@Episerver World Team</strong>, can we have a visible image caption? Now we can only enter description which is not visible and TinyMCE has the image_caption propery that could be used here)</p>
<p>So to create your first blog post enter the title for the blog post and click 'New Post' button. Then you get to the new post view which looks almost the same as if you were posting to Episerver World forums a new thread or replying but there is one additional button 'Save Draft' so when blogging you can save a draft and then later continue on the post.</p>
<p><img src="/link/b28e256d93e84fc4b3af0d5ca6c09edc.aspx" /></p>
<h2>Save draft and continue your writing</h2>
<p>So here is a demo about writing this blog post and then using the 'Save Draft' and continue work.</p>
<p><img src="/link/0822a0824e624ba8a5206274cc2cbee2.aspx" /></p>
<p>So You continue the work on a blog post from the "<a href="/link/5e37b120db614d1b8287a3b664f1a9ac.aspx">Manage your blog posts on Episerver World</a>" page and <span style="text-decoration: underline;">you have two options</span> now, <strong>edit</strong> or <strong>preview</strong>. Clicking 'Edit' takes you to page where you can edit Your page and 'Preview' opens a new window/tab in your browser where You can preview the page (so this is where the <strong>preview functionality</strong> has been hidden, if you are writing a new post and want to preview it then you first must save it as a draft so that you are able to preview it).</p>
<p>As a side note, during the save draft operation I got the 'I'm not a robot' hCaptcha verification screen from Cloudflare - don't panic! Just follow instructions on the screen :D</p>
<h2>What about then the editing experience</h2>
<p>It is the TinyMCE editor that we are used to in projects - only this time we are actually using it to create content ;-)</p>
<p>We can easily drag'n'drop or copy paste images from memory to the editor.</p>
<p>There are the usual formatting options:</p>
<ul>
<li>H1-H6, paragraph and preformatted</li>
<li><strong>bold</strong>, <span style="text-decoration: underline;">underline</span>, <em>italic</em>, <span style="text-decoration: line-through;">etc</span></li>
<li><span style="color: #ff6600;">text color</span> and <span style="background-color: #ffcc00;">text background</span> color</li>
<li>we can insert sample code</li>
<li>lists
<ul>
<li>with indenting</li>
</ul>
</li>
<li>insert <a>links</a></li>
<li>we can add tables (you shouldn't :D)</li>
<li>we can also preview from editor: View menu -> Preview
<ul>
<li>opens a smallish dialog where you can see your content from the editor but wihout page layout</li>
</ul>
</li>
</ul>
<p>In a few words - enough for me (almost).</p>
<h2>So what I mis- or dislike / limitations</h2>
<ul>
<li>I need to save a draft before I can use preview (<em>the full page preview</em>)
<ul>
<li>hCaptcha verification step (<em>Not always shown! but often and gets annoying when you fix typos/re-organize the content and want to review the full page</em>)</li>
<li>click preview in manage blog posts view to be able to see the post preview</li>
<li>then to continue work I need to click the edit</li>
<li>more steps than in normal flow when using Episerver CMS
<ul>
<li>but understandable if you think how You would implement this in a project and now allowing access to the Episerver edit view, you would end-up in similiar situation</li>
</ul>
</li>
</ul>
</li>
<li>Can not browse or re-use images that you have previously used
<ul>
<li>once again implementation details
<ul>
<li>we don't have access to edit view and that way have the possibility to use media assets</li>
<li>and currently blog post images are stored to the content assets folder of the blog page and not some 'siteassets/blogger-name'</li>
</ul>
</li>
</ul>
</li>
<li>If I remove an image and afterwards decide that I need it, I need to add it again
<ul>
<li>No idea was the image kept in backend or not</li>
<li>Yes, this is related to the browsing and re-using images</li>
</ul>
</li>
<li>Cannot use GitHub gist
<ul>
<li>well cannot use the embedded gist as it is JavaScript like this <script src="https://gist.github.com/alasvant/8baf56e26530a727a895ffcb69ea03ab.js"></script>
<ul>
<li>which gets HTML encoded to the page</li>
</ul>
</li>
<li>can use the link like this <a href="https://gist.github.com/alasvant/8baf56e26530a727a895ffcb69ea03ab">https://gist.github.com/alasvant/8baf56e26530a727a895ffcb69ea03ab</a> to link to the gist but idea is to have the gist rendered to the page without copy pasting it to the insert code sample
<ul>
<li>yes, the code sample is the workaround in this case</li>
</ul>
</li>
<li>we can use the 'View -> Source code' of the content in editor but we cannot add an iframe (gets stripped => not allowed)</li>
</ul>
</li>
<li>the menu item 'Insert' -> 'Template' is there but there are no ready made templates, so how the user is supposed to create their own templates and re-use those in different posts when the templates should be defined in the plug-in configuration and that naturally comes from server-side
<ul>
<li>so why is the 'Template' TinyMCE plug-in added as we can't use it?</li>
</ul>
</li>
<li>SEO
<ul>
<li>There is no meta description
<ul>
<li>@Episerver World Team, there really should be a text field / area for the meta description</li>
</ul>
</li>
<li>There is no author
<ul>
<li>@Episerver World Team, this could be automatically the blog name which usually is the name of the author?</li>
</ul>
</li>
<li>og:image is Episerver logo
<ul>
<li>well good that we at least have something</li>
<li>@Episerver World Team, could we some how get an option where the author of the blog post could upload the image to be used in the post
<ul>
<li>because now all the posts have the small Episerver logo which really is too small when someone wants to share the blog post to social media</li>
</ul>
</li>
</ul>
</li>
<li>there are other things that SEO tools report like canonical url missing and no language defined, etc, but those are minor things ;)</li>
</ul>
</li>
</ul>
<h2>Summary</h2>
<p> So there are some limitations, extra click workflows but in overall this is a really easy way to start blogging on Episerver World and sharing for the Episerver Community.</p>2020-09-20T09:25:17.0000000ZBlog postSwapcode.Episerver.AuditLog is now available in Episerver NuGet feedWhat is it and what it does? Keep reading to find out. In my previous blog post I wrote about how to write the content security changes to Episerver ‘Change Log’ (activity log) and then administrators can view and filter those changes in the out-of-the-box view. The actual code required for this is really simple […]2020-09-05T10:27:01.0000000ZBlog postEpiserver activity log with custom content security activityIn this post I will show you how you can create a custom content security activity and store that to Episerver activity log (change log) when access rights are changed in Episerver. This blog post was inspired by the fact that there is no out of the box audit log about content access rights changes […]2020-07-06T16:58:17.0000000ZBlog postEpiserver Content Delivery API new feature and optionsIf you missed the Episerver update 296 release notes or the Episerver Features February 2020 announcement – then this post is for you, because you have missed some important information about Episerver Content Delivery API. So keep on reading.. Episerver Content Delivery API new feature: support for local blocks Before version 2.9.0 of Content Delivery […]2020-03-22T13:05:52.0000000ZBlog postEpiserver Content Delivery API new feature and optionsIf you missed the Episerver update 296 release notes or the Episerver Features February 2020 announcement – then this post is for you, because you have missed some important information about Episerver Content Delivery API. So keep on reading.. Episerver Content Delivery API new feature: support for local blocks Before version 2.9.0 of Content Delivery […]2020-03-22T13:05:52.0000000ZBlog postEpiserver developer meetup Helsinki March 2020We had an awesome Episerver developer meetup in Helsinki. This time the years first meetup was kindly hosted by Solita Oy. Topics were this time: Episerver ASP.NET Core, customizing the Episerver Content Delivery API and a customer case utilizing Episerver CMS and real time public transport tracking. Of course there was also developer friendly menu: […]2020-03-05T19:35:38.0000000ZBlog postBroken Web API attribute routingHave you encountered the situation with your Episerver solution that your attribute based Web API starts throwing “The object has not yet been initialized. Ensure that HttpConfiguration.EnsureInitialized() is called in the application’s startup code after all other initialization code.”? If Yes, then this post is for you. The issue You have an Episerver solution and […]2020-01-12T13:07:48.0000000ZBlog postTinyMCE entity encodingJust a quick post about few TinyMCE settings that you might need when you use Episerver content created with “XhtmlString” property in some other context than web browser or you might be doing some manipulation to the content using XML structure. Default entity encoding is ‘named’ The default setting in TinyMCE entity_encoding is ‘named’ which […]2019-12-15T19:00:25.0000000ZBlog post