Blog posts by Peter Löfman2016-10-22T08:40:07.7270000Zhttps://world.optimizely.com/blogs/peter-lofman/Optimizely WorldForce Property Type Reset<p>During the development phase of a project it is, at least for me, rather common to change property names and property types when refactoring or otherwise improving the code. This can create a clutter of properties on a content type that are not being used as well as property type mismatch since <a href="/link/812ea3b3442e42d4bcf2449ee66f8375.aspx">Episerver can ony handle some property type cconversions automatically</a>. Episerver cannot for instance automatically convert a property that used to be a string to an int, which is very much understandable. And if you read up on <a href="/link/812ea3b3442e42d4bcf2449ee66f8375.aspx">refactoring content type classes</a> Episerver states that: "<span>If you need a change of [property] type and any data loss is acceptable, you can change the type of the property in admin mode, but you must temporarily remove the property from the code." </span></p>
<p><span>Having to go into admin mode and temporarily remove property from code is too bothersome for me so instead of doing something that would take a minute or two I spent a couple of hours trying to write some code that will do this automatically, and here is what I came up with.</span></p>
<p><span>First a created an atribute (I really did this last but it sounds better like this) to be placed on the property that you have changed the type of and which cannot be converted automatically, for instance a string to an int.</span></p>
<pre class="language-csharp"><code>[AttributeUsage(AttributeTargets.Property)]
public class ForceResetPropertyTypeAttribute : Attribute
{
}</code></pre>
<p>And you place it on a property like this. And, please be aware that all previous data will be lost since we will delete the property and then add it again with the new type.</p>
<pre class="language-csharp"><code>// I used to be a string but have been changed to an int
[ForceResetPropertyType]
[Display(GroupName = SystemTabNames.Content, Order = 100)]
public virtual int BackgroundColor { get; set; }</code></pre>
<p>Next a made an <a href="/link/b3c10fa7ea5a492bafd245ced7ddc939.aspx">initialization module</a> that (1) deletes all properties that are missing in code and (2) scans each content type model for the attribute ForceResetPropertyTypeAttribute I create before, and simply deletes the property with all its data from Episerver and then re-adds it with the new property definition.</p>
<pre class="language-csharp"><code>[ModuleDependency(typeof(EPiServer.Web.InitializationModule))]
public class ResetContentTypeslInitialization : IInitializableModule
{
public void Initialize(InitializationEngine context)
{
var contentTypeRepository = ServiceLocator.Current.GetInstance<IContentTypeRepository>();
var propertyDefinitionRepository = ServiceLocator.Current.GetInstance<IPropertyDefinitionRepository>();
var contentTypeModelRepository = ServiceLocator.Current.GetInstance<ContentTypeModelRepository>();
var propertyDefinitionSynchronizer =
(PropertyDefinitionSynchronizer)ServiceLocator.Current.GetInstance<IPropertyDefinitionTypeResolver>();
// foreach (var contentType in contentTypeRepository.List()) - takes all content types
// and not just yours and will actually remove to much
foreach (
var contentType in
contentTypeRepository.List()
.Where(ct => !string.IsNullOrEmpty(ct.ModelTypeString)
&& ct.ModelTypeString.StartsWith("Your.Assembly.Containing.The.Content.Types")))
{
// First we delete all properties that do not exist in code - probably due to renaming them
var propertyDefinitionsThatDoNotExistInCode =
contentType.PropertyDefinitions.Where(
propertyDefinition => IsMissingModelProperty(propertyDefinition, contentTypeModelRepository));
foreach (var propertyDefinition in propertyDefinitionsThatDoNotExistInCode)
{
propertyDefinitionRepository.Delete(propertyDefinition);
}
var modelType = contentType.ModelType;
if (modelType == null) continue;
// Next we want to check if there are any content types that have a property with the
// ForceResetPropertyTypeAttribute placed on them, and if so delete and re-add the property
// definition.
foreach (var propertyInfo in modelType.GetProperties())
{
var forceResetPropertyTypeAttribute =
propertyInfo.GetCustomAttribute<ForceResetPropertyTypeAttribute>();
if (forceResetPropertyTypeAttribute == null) continue;
var propertyName = propertyInfo.Name;
var contentTypeModel = contentTypeModelRepository.GetContentTypeModel(modelType);
var propertyDefinition = contentType.PropertyDefinitions.Single(pd => pd.Name.Equals(propertyName));
var propertyDefinitionModel =
contentTypeModel.PropertyDefinitionModels.Single(p => p.Name.Equals(propertyName));
// We check the current property definition type to see if perhaps we have already made the conversion.
// We do not want to remove data on an already converted property
var propertyDefinitionType = propertyDefinitionSynchronizer.ResolveType(propertyDefinitionModel);
if (propertyDefinition.Type.DefinitionType == propertyDefinitionType.DefinitionType) continue;
// And finally here we delete the property definition and then re-adds it according to the new information
// Please be aware that this will delete all the data as well.
propertyDefinitionRepository.Delete(propertyDefinition);
propertyDefinitionSynchronizer.CreatePropertyDefinition(propertyDefinitionModel, contentType.ID);
}
}
}
private static bool IsMissingModelProperty(
PropertyDefinition propertyDefinition,
ContentTypeModelRepository contentTypeModelRepository)
{
if (propertyDefinition == null) return false;
if (!propertyDefinition.ExistsOnModel) return true;
return contentTypeModelRepository.GetPropertyModel(propertyDefinition.ContentTypeID, propertyDefinition)
== null;
}
public void Uninitialize(InitializationEngine context)
{
}
}</code></pre>
<p><span>[Pasting files is not allowed]</span><span>[Pasting files is not allowed]</span></p>2016-10-22T08:40:07.7270000ZBlog postProperty Validations<p>Inspiration for this blog post comes from the blog post on <a href="/link/e5beed92a6744aa0b223180c1d9905a0.aspx">page validations</a> and I wanted to spin a little further on this subject by creating a flexible validation atttribute you can place on the property to validate.</p>
<p>I wanted to use lamba expression but didn't realize that <a href="http://stackoverflow.com/questions/4411122/c-sharp-method-attribute-cannot-contain-a-lambda-expression">you cannot do that</a>, so I then started trying other means of getting the flexibility I wanted to achieve befaore finding a wonderful little blog post on how to <a href="http://www.codeproject.com/Articles/11939/Evaluate-C-Code-Eval-Function">evaluate c# code</a>. This makes it possible to write a string lambda expression and then compile this into to valid code you can use.</p>
<p>Anyway, enough history on the origins of this blog post let's dive into how to make property validation flexible and versatile.</p>
<p><strong>Examples of the ValidateAttribute</strong></p>
<p>My thinking was that you should be able to create multiple validation rules for each property with different levels of severity. And, you should also be able to use the current PageData instance in order to compare with other properties on the same PageData instance.</p>
<pre class="language-csharp"><code>[Validate(
"(str, pageData) => str != null || pageData.MetaDescription != null",
ValidationErrorSeverity.Error,
"MyTitle is empty.")]
[Validate(
"str => str == null || str.Length > 10",
ValidationErrorSeverity.Info,
"MyTitle is a bit short - should be at least 10 characters.")]
[Display(GroupName = SystemTabNames.Content, Order = 1000)]
public virtual string MyTitle { get; set; }
[Validate(
"dateTime => dateTime >= new DateTime(2016, 10, 01)",
ValidationErrorSeverity.Error,
"MyDateTime must be greater than or equal to 20016-10-01")]
[Display(GroupName = SystemTabNames.Content, Order = 2000)]
public virtual DateTime MyDateTime { get; set; }</code></pre>
<p>There are three properties of the ValidateAttribute: Expression, Severity, and Message. </p>
<p>The expression can be of two types:</p>
<pre class="language-csharp"><code>Func<dynamic, bool></code></pre>
<p>or </p>
<pre class="language-csharp"><code>Func<dynamic, dynamic, bool></code></pre>
<p>The first simple takes the value of the property and validates against it and the latter also takes the PageData instance into account.</p>
<p>Next we need a class that implements IValidate<PageData> in order to look through all the properties on the current PageData instance and validate against any possible ValidateAttributes and that's really it. </p>
<p>The two classes needed are the ones that follow.</p>
<p><strong>ValidateAttribute</strong></p>
<pre class="language-csharp"><code>using System;
using EPiServer.Validation;
/// <summary>
/// Validates a string expression against a PageData instance.
/// <example>propertyValue => propertyValue != null</example>
/// <example>(propertyValue, pageData) => propertyValue != null || pageData.AnotherProperty != null</example>
/// </summary>
[AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
public class ValidateAttribute : Attribute
{
/// <summary>
/// The validation expression, of <see cref="Func{dynamic,Boolean}"/>.
/// </summary>
public string ValidationExpression { get; set; }
/// <summary>
/// The Severity if failing the validation.
/// </summary>
public ValidationErrorSeverity Severity { get; set; }
/// <summary>
/// The message to be displayed if the validation fails.
/// </summary>
public string Message { get; set; }
/// <summary>
/// The constructor for using the ValidateAttribute
/// </summary>
/// <param name="validationExpression">The validation expression, of <see cref="Func{dynamic,Boolean}"/>.</param>
/// <param name="severity">The Severity if failing the validation.</param>
/// <param name="message">The message to be displayed if the validation fails.</param>
public ValidateAttribute(string validationExpression, ValidationErrorSeverity severity, string message)
{
this.ValidationExpression = validationExpression;
this.Severity = severity;
this.Message = message;
}
}</code></pre>
<p><strong>ValidateContent</strong></p>
<pre class="language-csharp"><code>using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using EPiServer;
using EPiServer.Core;
using EPiServer.Validation;
using Microsoft.CSharp;
public class ValidateContent : IValidate<PageData>
{
public IEnumerable<ValidationError> Validate(PageData instance)
{
// A dictionary with property name as key with multiple validate attributes as value.
var propertyValidateAttributes =
instance.GetOriginalType()
.GetProperties()
.Select(
propertyInfo =>
new
{
propertyInfo.Name,
ValidateAttributes = propertyInfo.GetCustomAttributes<ValidateAttribute>()
})
.Where(i => i.ValidateAttributes != null)
.ToDictionary(i => i.Name, i => i.ValidateAttributes);
var validationErrors = new List<ValidationError>();
foreach (var propertyValidationAttribute in propertyValidateAttributes)
{
foreach (var validateAttribute in propertyValidationAttribute.Value)
{
var isValid = IsValid(
validateAttribute.ValidationExpression,
instance.Property[propertyValidationAttribute.Key].Value,
validateAttribute.ValidationExpression.StartsWith("(") ? instance : null);
if (isValid) continue;
validationErrors.Add(
new ValidationError
{
ErrorMessage = validateAttribute.Message,
PropertyName = propertyValidationAttribute.Key,
Severity = validateAttribute.Severity,
ValidationType = ValidationErrorType.AttributeMatched
});
}
}
return validationErrors;
}
//http://www.codeproject.com/Articles/11939/Evaluate-C-Code-Eval-Function
public static bool IsValid(string expression, object propertyValue, PageData pageData = null)
{
var codeProvider = new CSharpCodeProvider();
var compilerParameters = new CompilerParameters();
compilerParameters.ReferencedAssemblies.Add("System.Core.dll");
compilerParameters.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
compilerParameters.CompilerOptions = "/t:library";
compilerParameters.GenerateInMemory = true;
var sb = new StringBuilder();
sb.Append("using System;\n");
sb.Append("using System.Linq.Expressions;\n");
sb.Append("namespace ExpressionEvaluate {\n");
sb.Append("public class ExpressionEvaluate {\n");
sb.Append("public static Func<dynamic" + (pageData != null ? ", dynamic" : "") + ", bool> Expression { get { return " + expression + "; } }\n");
sb.Append("}\n");
sb.Append("}\n");
var compilerResults = codeProvider.CompileAssemblyFromSource(compilerParameters, sb.ToString());
if (compilerResults.Errors.Count > 0)
{
throw new Exception(string.Join("; ", compilerResults.Errors));
}
var compiledAssembly = compilerResults.CompiledAssembly;
var instance = compiledAssembly.CreateInstance("ExpressionEvaluate.ExpressionEvaluate");
if (instance == null)
throw new Exception("Could not create an instance of the expression evaluator.");
var instanceType = instance.GetType();
var propertyInfo = instanceType.GetProperty("Expression", BindingFlags.Static | BindingFlags.Public);
var func = propertyInfo.GetGetMethod().Invoke(instance, null);
return pageData != null
? ((Func<dynamic, dynamic, bool>)func)(propertyValue, pageData)
: ((Func<dynamic, bool>)func)(propertyValue);
}
}</code></pre>
<p><strong>User interaction</strong></p>
<p>And if using the validation rules as depicted in the <em>Examples of the ValidationAttribue</em> section, the following outcome could appear.</p>
<p><img src="/link/35fd887ecb244bf291b5604bcd7f9193.aspx" alt="Image validate-attribute-example.png" /></p>2016-09-25T11:19:19.3670000ZBlog post