Blog posts by Santosh Achanta

Correction to no wrappers content area renderer

Thu, 24 May 2018 05:30:30 GMT

Referring to Krzysztof Morcinek's blog post which is used quite a lot in the epi world, thought to share a small correction to it.

The below piece of code from the blog post renders all the items while you're in edit mode which doesn't allow users to test personalized content.

_contentRequestContext.IsInEditMode(helper.ViewContext.HttpContext)
? contentArea.Contents
: contentArea.FilteredContents

So, this piece of code can be safely replaced with the below which will just render the same items rendered by the out of the box content area renderer which allows users to test how personalized content looks like.

contentArea.FilteredItems

FormattingJsonAttribute for camel case formatting of variable names and converting enums to strings

Wed, 05 Oct 2016 00:02:05 GMT

I am tired of using JsonProperty decorator for each class member so decided to do something that will automatically take care of camel case conversion of variable names for Json response.

"FormattingJson" is a decorator for a class or a method to convert property names to camel case and enum values to strings whle serializing response object.

Usage: Decorate a class(eg. a API controller) or a method with the below

[FormattingJson(FormatterTypes.CamelCase, FormatterTypes.EnumToString)]

Underlying functions those are respinsible for this utility are CamelCasePropertyNamesContractResolver and StringEnumConverter from Newtonsoft.Json library.

Below is the code for implementation.

using System;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Web.Http.Filters;
using Episerver.Web.Site.Attributes.Formatting.Formatters;

namespace Episerver.Web.Site.Attributes.Formatting
{
    /// <summary>
    /// Apply required formatting on the response content
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
    public sealed class FormattingJsonAttribute : ActionFilterAttribute
    {
        private readonly FormatterTypes[] _formatterTypes;

        /// <summary>
        /// Initializes a new instance of the <see cref="FormattingJsonAttribute"/> class.
        /// </summary>
        /// <param name="formatterTypes">The formatter types.</param>
        /// <exception cref="System.ArgumentException">At least one formatter type must be provided;formatterTypes</exception>
        public FormattingJsonAttribute(params FormatterTypes[] formatterTypes)
        {
            if (formatterTypes == null || !formatterTypes.Any())
            {
                throw new ArgumentException("At least one formatter type must be provided");
            }

            _formatterTypes = formatterTypes;
        }

        /// <summary>
        /// Occurs after the action method is invoked.
        /// </summary>
        /// <param name="actionExecutedContext">The action executed context.</param>
        public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
        {
            if (actionExecutedContext == null || actionExecutedContext.Response == null)
            {
                return;
            }

            var content = actionExecutedContext.Response.Content as ObjectContent;

            if (content != null)
            {
                var jsonFormatter = new JsonMediaTypeFormatter();
                if (content.Formatter is JsonMediaTypeFormatter)
                {
                    var factory = new FormatterFactory();

                    foreach (var formatter in _formatterTypes)
                    {
                        factory.Create(formatter)
                            .Apply(jsonFormatter);
                    }

                    actionExecutedContext.Response.Content = new ObjectContent(content.ObjectType, content.Value, jsonFormatter);
                }
            }
        }
    }
}

namespace Episerver.Web.Site.Attributes.Formatting
{
    public enum FormatterTypes
    {
        /// <summary>
        /// Changes it from 'CamelCase' to 'camelCase'.
        /// </summary>
        CamelCase = 1,

        /// <summary>
        /// Returns the 'string' version of the enum. The default parsing is 'int'. Example: BalancePosition.Credit will be 'Credit' not '0'
        /// </summary>
        EnumToString = 2
    }
}

using System.Net.Http.Formatting;
using Newtonsoft.Json.Serialization;

namespace Episerver.Web.Site.Attributes.Formatting.Formatters
{
    /// <summary>
    /// Converts output to camel case
    /// </summary>
    public class CamelCaseFormatterApplier : IFormatterApplier
    {
        /// <summary>
        /// Applies the specified formatter.
        /// </summary>
        /// <param name="formatter">The formatter.</param>
        public void Apply(JsonMediaTypeFormatter formatter)
        {
            formatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
        }
    }
}

using System.Net.Http.Formatting;
using Newtonsoft.Json.Converters;

namespace Episerver.Web.Site.Attributes.Formatting.Formatters
{
    /// <summary>
    /// Converts enums from int to string
    /// </summary>
    public class EnumStringFormatterApplier : IFormatterApplier
    {
        /// <summary>
        /// Applies the specified formatter.
        /// </summary>
        /// <param name="formatter">The formatter.</param>
        public void Apply(JsonMediaTypeFormatter formatter)
        {
            formatter.SerializerSettings.Converters.Add(new StringEnumConverter());
        }
    }
}

using System.Net.Http.Formatting;

namespace Episerver.Web.Site.Attributes.Formatting.Formatters
{
    /// <summary>
    /// Applies formatting to the response output
    /// </summary>
    public interface IFormatterApplier
    {
        /// <summary>
        /// Applies the specified formatter.
        /// </summary>
        /// <param name="formatter">The formatter.</param>
        void Apply(JsonMediaTypeFormatter formatter);
    }
}

using System;

namespace Episerver.Web.Site.Attributes.Formatting.Formatters
{
    /// <summary>
    /// Creates formatters
    /// </summary>
    public class FormatterFactory
    {
        /// <summary>
        /// Creates the approriate formatter
        /// </summary>
        /// <param name="formatterType"></param>
        /// <returns></returns>
        public IFormatterApplier Create(FormatterTypes formatterType)
        {
            switch (formatterType)
            {
                case FormatterTypes.CamelCase:
                    return new CamelCaseFormatterApplier();

                case FormatterTypes.EnumToString:
                    return new EnumStringFormatterApplier();

                default:
                    throw new ArgumentOutOfRangeException("formatterType", formatterType, "Invalid formatter type");
            }
        }
    }
}

Only find pages those hold data with no shortcut link to other pages, etc.

Thu, 26 Jun 2014 13:05:27 GMT

I had a requirement to find only pages those doesn't have shortcut link to another page or fetch data from another page etc means those pages holding the actual property data that needs to be manipulated.

When I couldn’t find quickly on how that can be done using property criteria using the FindPagesWithCriteria method, I stumbled on digging little bit into EPiServer.Core and found that the PageShourtcutType is of type enum which has the first option ‘Normal = 0’ which I need to look for.

When I debug the PageDataCollection before filtering with criteria, I noticed that the value stored is a number.

So my code snippet as below and it worked like a charm in the first instance.

new PropertyCriteria {
    Condition = CompareCondition.Equal,
    Type = PropertyDataType.Number,
    Name = "PageShortcutType",
    Value = "0",
    Required = true
}

Tailoring workflows for EPiServer 5, 6 and 7

Sun, 27 Jan 2013 20:47:00 GMT

We have enabled out of the box Sequential workflow for one of our customers, the workflow starts when an editor modify or create a page and push 'Ready to Publish' button. Then an approver receives the workflow email and by default the email is from 'task@<hosturl>' if from address is not set up in web.config SMTP settings. So, I have digged into EPiServer.WorkflowFoundation.dll to see why it is happening and found that when a workflow is triggered, it creates a task and use the method SendMail(string fromUser, string toUser, string mailSubject) in EPiServer.Personalization.Task in EPiServer.dll to send email to approvers and by default it look for current user's email id which is not valid in this case as the workflows executes in own threads separate from the thread serving the request and hence the from email address is the fallback one which is 'task@<hosturl>' all the time. Our customer wants the from email address to be the editor’s email address so that the approver knows from the email who actually the editor of the page is.

Solution for this is, get the code for the sequential approval workflow. In there they should locate the activities named “initializeApprovalState” and “InitializeUpdateState”. Inside these there is an activity called “createApprovalTask” and “createOwnerTask” respectively, if these activities are marked and select view properties, a property “NotifyByEmail” can be set to false. Then the builtin email will not be sent.

Then before or after the “createApprovalTask” and “createOwnerTask” activities you can drag in one “SendEmailActivity” in that activity where you can then control how the outgoing email should look like.

See this post for downloading workflow code http://world.episerver.com/Blogs/Johan-Bjornfot/Dates1/2011/8/Source-code-for-the-CMS6R2-built-in-workflows/.

See this post for the steps to get the workflows loaded properly http://geekswithblogs.net/SoftwareDoneRight/archive/2008/01/19/howto-set-up-your-project-for-windows-workflow-c-style.aspx.

This blog post applies for workflows in EPiServer 5, 6 and 7 versions and hopefully workflows in the product will be modified and implement this in mere future.

Let me know if someone is after the same requirement and code for this implementation as I did this already.

Issue with browsing files in browser having special characters in file name and fix

Thu, 22 Nov 2012 02:33:07 GMT

After upgrading one of our very old customer’s website from EPiServer 4.62 to CMS 6 R2, it was reported that documents with special characters in file name (for e.g. ‘S&R12.pdf’) throwing ‘System.Web.HttpException: A potentially dangerous Request.Path value was detected from the client (&).’ when they are being opened up in browser.

Fix for this is issue is to just add requestPathInvalidCharacters="" if you want to allow all special characters.

The above attribute must be added to the element <httpRuntime> in your website’s web.config so that it will look as follows:

<configuration>

<system.web>

<httpRuntime requestValidationMode="2.0" requestPathInvalidCharacters="" />

</system.web>

</configuration>

If you want to restrict certain special characters then make sure you specify them as requestPathInvalidCharacters="<,>,*,%,:,&,\"