Blog - Glass and SXA - Part 2

Glass and SXA - Part 2

In part 1 of this blog post series we look at the two different rendering mechanism in SXA. In this section we will look at how we can use Glass models with SXA.

Before I continue I should mention the excellent work by David San Filippo who has created a module to help you get started with Glass.Mapper.Sc and SXA. You can check this work out using the links below:

• Blog Post: http://www.mtelligent.com/home/2018/3/1/using-glass-mapper-with-sxa
• Github: https://github.com/mtelligent/Glass-Controllers-for-Sitecore-Experience-Accelerator

If you look at David’s solution you will see that is uses a composite model solution. This is an excellent solution because it separates the Glass model from the SXA model.

I am going to look at a slightly different solution based on the Glass model inherit the RenderingModelBase.

One of the features of Glass is the ability to mix models with different data sources this feature we can use this to our advantage to create an inherited model.

My basic Glass model looks like this:

    [SitecoreType(AutoMap = false)]
    public class MyModel : RenderingModelBase
    {
        [SitecoreId]
        public virtual Guid Id { get; set; }

        [SitecoreField("Title")]
        public virtual string Title { get; set; }

        [SitecoreField("Description")]
        public virtual string Description { get; set; }

        [SitecoreField("Logo")]
        public virtual Image Logo { get; set; }
    }

Things to note about this model:

• It inherits from RenderingModelBase
• The configuration explicitly disables automapping. You must disable automapping to avoid base properties from being mapped, this needs to be done for both fluent and attribute configuration. By disabling automapping this stops Glass from trying to map the properties on the base RenderingModelBase class.
• Each property is explicitly configured to tell Glass how the property should be mapped.

With our model created we now need to setup our SXA repository:

    public class DemoRepository : ModelRepository
    {
        private readonly ISitecoreService sitecoreService;

        public DemoRepository(ISitecoreService sitecoreService)
        {
            this.sitecoreService = sitecoreService;
        }

        public override IRenderingModelBase GetModel()
        {
            var model = sitecoreService.GetItem<MyModel>(this.PageContext.Current);
            FillBaseProperties(model);
            return model;
        }
    }

The model is first created by Glass and then passed to SXA so that it can set the properties it requires. The model can then be passed to the view for rendering using the Glass and SXA features.

The Summary

The choice of using an inherited model or a composite model is a personal choice. I have demonstrated the inherited model above to show one solution but personally I think that the composite model solution developed by David is probably a better way to go. It gives a cleaner separation between Glass and SXA.

You still need to be clear on why you are mixing Glass with SXA in a single rendering and the trade-offs that will have. This mainly relates to using rendering variants in SXA. One area where Glass maybe very useful in a rendering is in the controller. If your SXA rendering needs more complex controller logic based on Sitecore data then Glass can certainly be helpful here.

Using both Glass and SXA in the same solution can work well, where simpler renderings are built with SXA and more complex renderings that are driven by business rules are built using Glass.

What are your thoughts?

- Mike