Skip to main content

A DD4T.net Implementation - Model Builders

In my previous post I was talking about the Strong Typed models and how they are used to give a class representation for Tridion Schemas. In this post I will talk about how we can build such models from Components.

The model builders are derived from a generic Builder class that converts either an IComponent or IFieldSet to an implementation of BaseModel class:

    public abstract class Builder<From, To> where To : BaseModel
    {
        public abstract To Build(From fromValue);

        public IList<To> Build(IList<From> fromValueList)
        {
            if (fromValueList == null || fromValueList.Count == 0)
            {
                return new List<To>();
            }

            return fromValueList.Select(x => Build(x)).ToList<To>();
        }
    }


The abstract Build(From object) needs to be implemented by all classes that extend Builder. That is where the actual building of the model takes place.

The other method IList<To> Build(IList<From> objects) is simply a convenience method that builds an array of model from an array of IComponent or IFieldSet objects.

A Builder implementation class can take an IComponent 'from' object and convert it into a derivative of BaseModel object. The Builder can also take IFieldSet 'from' object, in the case when building embedded models. This is needed because the embedded fields don't have a corresponding IComponent; they are simply identified by a set of DD4T.ContentModel.IField -- the IFieldSet.

Let's see further an actual implementation of a Builder for Device models. First let's look at the Device model class:

    public class Device : BaseModel
    {
        public Banner Banner { get; set; }
        public IList<EmbeddedParagraph> Body { get; set; }
        public IList<BaseModel> RelatedItems { get; set; }
        public DeviceMetadata Metadata { get; set; }

        public class DeviceMetadata
        {
            public double LegacyId { get; set; }
            public string ShortTitle { get; set; }
            public IList<IKeyword> Products { get; set; }
            public DateTime UpdateDate { get; set; }
        }

        public Device(IComponent component) : base(component) { }
    }


The corresponding DeviceBuilder for the sample model looks like this:

    public class DeviceBuilder : Builder<IComponent, Device>
    {
        private static readonly DeviceBuilder _instance = new DeviceBuilder();
        public static DeviceBuilder Instance { get { return _instance; } }

        private DeviceBuilder() {}

        public override Device Build(IComponent component)
        {
            IFieldSet fields = component.Fields;
            IFieldSet metadataFields = component.MetadataFields;
            Device device = new Device(component)
            {
                Banner = BannerBuilder.Instance.Build(fields.LinkedComponentValue("Banner")),
                Body = EmbeddedParagraphBuilder.Instance.Build(fields.EmbeddedValues("Body")),
                RelatedItems = RelatedItemBuilder.Instance.Build(fields.LinkedComponentValues("Related_Items")),

                Metadata = new Device.DeviceMetadata()
                {
                    LegacyId = metadataFields.NumericValue("Legacy_Id"),
                    ShortTitle = metadataFields.StringValue("Short_Title"),
                    Products = metadataFields.KeywordValues("Products"),
                    UpdateDate = metadataFields.DateTimeValue("Update_Date")
                }
            };

            return device;
        }
    }


First, DeviceBuilder is declared as a Builder that takes an IComponent as 'from' object and produces a Device as 'to' object.

Then comes the singleton declaration. We know this builder is thread-safe (it doesn't use any internal state other than what is passed to it from method parameters), so it can be declared a singleton to improve performance.

Next, the actual Build method: this is the main logic of the builder. It takes each field in the IComponent field collection and metadata field collection and populates the properties of the Device model. You might notice the methods on the 'fields' collection, such as NumericValues, KeywordValues, DateTimeValue... These are not standard methods on the IFieldSet object, but are declared as extension methods. But, more information about those in a future post.

The other Builders are very similar -- BannerBuilder, RelatedItemBuilder. But the EmbeddedParagraphBuilder stands out because it is a bit different. It doesn't take an IComponent to build an EmbeddedParagraph model. Instead it take the embedded set of fields to produce an EmbeddedParagraph.

The EmbeddedParagraphBuilder implementation is next:

    public class EmbeddedParagraphBuilder : Builder<IFieldSet, EmbeddedParagraph>
    {
        private static readonly EmbeddedParagraphBuilder _instance = new EmbeddedParagraphBuilder();
        public static EmbeddedParagraphBuilder Instance { get { return _instance; } }

        private EmbeddedParagraphBuilder() {}

        public override EmbeddedParagraph Build(IFieldSet fields)
        {
            EmbeddedParagraph paragraph = new EmbeddedParagraph()
            {
                Heading = fields.StringValue("Heading"),
                Body = fields.ResolveRichText("Body")
            };

            return paragraph;
        }
    }


Once the Builders are implemented, we simply use them by passing in an IComponent object. For example in a ComponentController:

        public ActionResult Device(string componentPresentationId)
        {
            IComponentPresentation cp = GetComponentPresentation();
            IComponent component = cp.Component;

            Device device = DeviceBuilder.Instance.Build(component);

            return View();
        }





Comments

Popular posts from this blog

Running sp_updatestats on AWS RDS database

Part of the maintenance tasks that I perform on a MSSQL Content Manager database is to run stored procedure sp_updatestats . exec sp_updatestats However, that is not supported on an AWS RDS instance. The error message below indicates that only the sa  account can perform this: Msg 15247 , Level 16 , State 1 , Procedure sp_updatestats, Line 15 [Batch Start Line 0 ] User does not have permission to perform this action. Instead there are several posts that suggest using UPDATE STATISTICS instead: https://dba.stackexchange.com/questions/145982/sp-updatestats-vs-update-statistics I stumbled upon the following post from 2008 (!!!), https://social.msdn.microsoft.com/Forums/sqlserver/en-US/186e3db0-fe37-4c31-b017-8e7c24d19697/spupdatestats-fails-to-run-with-permission-error-under-dbopriveleged-user , which describes a way to wrap the call to sp_updatestats and execute it under a different user: create procedure dbo.sp_updstats with execute as 'dbo' as

Content Delivery Monitoring in AWS with CloudWatch

This post describes a way of monitoring a Tridion 9 combined Deployer by sending the health checks into a custom metric in CloudWatch in AWS. The same approach can also be used for other Content Delivery services. Once the metric is available in CloudWatch, we can create alarms in case the service errors out or becomes unresponsive. The overall architecture is as follows: Content Delivery service sends heartbeat (or exposes HTTP endpoint) for monitoring Monitoring Agent checks heartbeat (or HTTP health check) regularly and stores health state AWS lambda function: runs regularly reads the health state from Monitoring Agent pushes custom metrics into CloudWatch I am running the Deployer ( installation docs ) and Monitoring Agent ( installation docs ) on a t2.medium EC2 instance running CentOS on which I also installed the Systems Manager Agent (SSM Agent) ( installation docs ). In my case I have a combined Deployer that I want to monitor. This consists of an Endpoint and a

Debugging a Tridion 2011 Event System

OK, so you wrote your Tridion Event System. Now it's time to debug it. I know this is a hypothetical situtation -- your code never needs any kind of debugging ;) but indulge me... Recently, Alvin Reyes ( @nivlong ) blogged about being difficult to know how exactly to debug a Tridion Event System. More exactly, the question was " What process do I attach to for debugging even system code? ". Unfortunately, there is no simple or generic answer for it. Different events are fired by different Tridion CM modules. These modules run as different programs (or services) or run inside other programs (e.g. IIS). This means that you will need to monitor (or debug) different processes, based on which events your code handles. So the usual suspects are: dllhost.exe (or dllhost3g.exe ) - running as the MTSUser is the SDL Tridion Content Manager COM+ application and it fires events on generic TOM objects (e.g. events based on Tridion.ContentManager.Extensibility.Events.CrudEven