Tridion Developer

Using XPath to find XML Elements with Inline/Default Namespace and Null Prefix

Nickoli Roussakov — Thu, 26 Jan 2012 05:36:29 +0000

On the last SDL Tridion Community Webinar, Dominic Cronin suggested a great alternative to Regex for finding, adding, removing, or replacing certain elements or attributes, such as Component Links within Components (or Pages). The more data-safe approach is to manipulate the Component source as an XML document [via XPath] rather than regex. I gave it a shot, except that getting (what seems like) a simple XPath query to work took way more effort than I anticipated. All of this due to a little unknown detail about XPath queries for items in the default namespace without a prefix.

In this scenario, the Tridion XML source for a component has elements with inline (or default) xhtml namespaces declared right on the element that we’re searching for, and no prefix. For example, in the XML below such elements are the anchor and paragraph tags:

Hello Internets!

Welcome to our website. This is some random content that isn’t doing very much, except this link

This is some more body content that has been put into the page.

A basic XPath query such as myXmlDocument.SelectNode(“//p”) should return all the

elements in the document, however, since they’re part of the default “http://www.w3.org/1999/xhtml” namespace, you get nothing back from your search – very annoying: thanks XPath engine for making it so hard! If only there had been a prefix, e.g.

then the XPath query would be a no brainer: myXmlDocument.SelectNode(“//xhtml:p”), and we’d select all the

nodes in the document within that namespace.

Actually, even though you don’t see a prefix in the above example, there actually is one. It’s called the NULL prefix. And the way you select nodes with a NULL prefix in C# is as follows:

XmlDocument componentXml = componentItem.GetAsXmlDocument();
XmlNamespaceManager nsMgr = new XmlNamespaceManager(componentXml.NameTable);
nsMgr.AddNamespace(“null”, “http://www.w3.org/1999/xhtml”);
foreach (XmlElement pNode in componentXml.SelectNodes(“//null:p“, nsMgr))
{
//do stuff with the pNode,
//such as (random example) remove it completely from the document.

pNode.ParentNode.RemoveChild(pNode);
}

Notice above, the xhtml namespace is added to the NamespaceManager with the “null” prefix, and then the XPath query selects the

tag with that prefix? That’s it!

Happy coding!

Generating Web.Sitemap from Tridion (SiteMapDataSource)

Nickoli Roussakov — Sat, 21 Jan 2012 03:14:39 +0000

In spirit of Nuno’s post last week (http://nunolinhares.blogspot.com/2012/01/its-little-things-creating-page.html) regarding website navigation and more specifically, how to generate a Breadcrumb from Structure Groups in Tridion, I thought it was time to publish a related post (and a TBB) I’ve been baking for a while now. Behold: hooking up Tridion to .NET’s standard Navigation Controls. I’m talking about Menu, SiteMapPath, and TreeView. Turns out they all feed off the same, rather basic, XML file called web.sitemap. Here is the C# code for a generic TBB that creates such a file from your SDL Tridion Web Structure Group and Pages hierarchy.

Here is the basic structure of a .sitemap file:

Naturally, in Tridion (and almost any website) the Structure Groups are organized in much the same way. So it shouldn’t be too hard to generate one of these files by recursively traversing through the SGs and pages. … and writing a recursive algorithm is always fun.

So here is a TBB that you can plug into a new Page Component Template that will generate and publish a web.sitemap file based on your Structure Groups.

I do want to mention that if you have some funky business rules and handle them through Page or SG Metadata fields (most implementations do), then add a method to this code that gets the relevant Page or SG (e.g. engine.GetObject(tcmId); ), extracts the field value(s) and appends them as attributes to the siteMapNodes.

Just copy/paste the following code into a new class in your TBB project assembly. Happy Tridionizing y’all!


using System.Xml;
using Tridion.ContentManager.Templating;
using Tridion.ContentManager;
using Tridion.ContentManager.CommunicationManagement;
using Tridion.ContentManager.Templating.Assembly;
using System;

namespace ContentBloom.Templates
{
    ///
    ///

    /// This SDL Tridion building block recursively iterates over the
    /// Structure Groups of a publication and generates an ASPX.NET Web.sitemap
    /// file which can be pluged in as a DataSource into a TreeView, Breadcrumb
    /// and other .NET navigation User Controls.
    /// 

    [TcmTemplateTitle("Generate Web.sitemap")]
    public class GenerateWebSitemap : ITemplate
    {
        private Engine engine;
        private Package package;
        private static readonly TemplatingLogger log = TemplatingLogger.GetLogger(typeof(GetWebSitemap));

        private static string xmlns = "http://schemas.microsoft.com/AspNet/SiteMap-File-1.0";

        public void Transform(Engine engine, Package package)
        {
            //Initialize
            this.engine = engine;
            this.package = package;

            Page page = null;
            Item pageItem = package.GetByType(ContentType.Page);
            if (pageItem != null)
            {
                page = engine.GetObject(pageItem.GetAsSource().GetValue("ID")) as Page;
            }
            else
            {
                throw new InvalidOperationException("No Page found.  Verify that this template is used with a Page.");
            }
            Publication mainPub = page.ContextRepository as Publication;
            StructureGroup rootSg = mainPub.RootStructureGroup;
            XmlDocument sitemapDoc = GenerateSitemap(rootSg);

            package.PushItem(Package.OutputName, package.CreateXmlDocumentItem(ContentType.Xml, sitemapDoc));
        }

        private XmlDocument GenerateSitemap(StructureGroup sg, XmlElement parent=null, XmlDocument doc=null)
        {
            if (doc == null)
            {
                //create base doc
                doc = new XmlDocument();
                XmlDeclaration xmlDeclaration = doc.CreateXmlDeclaration("1.0", "utf-8", null);
                doc.InsertBefore(xmlDeclaration, doc.DocumentElement);
            }
            if (parent == null)
            {
                //create root sitemap element and append to the doc.
                XmlElement root = doc.CreateElement("siteMap", xmlns);
                doc.AppendChild(root);

                parent = doc.CreateElement("siteMapNode", xmlns);
                root.AppendChild(parent);
                parent.SetAttribute("url", sg.PublishLocationUrl);
                parent.SetAttribute("title", RemoveNumberPrefix(sg.Title));
            }

            // Get the list of child structure groups and pages in this SG
            Filter filter = new Filter();
            filter.Conditions["ItemType"] = 68;//pages, structure groups
            filter.BaseColumns = ListBaseColumns.Extended;

            XmlElement childItems = sg.GetListItems(filter);
            foreach (XmlElement item in childItems.SelectNodes("*"))
            {
                string isPublished = item.GetAttribute("IsPublished");
                string itemType = item.GetAttribute("Type");
                string itemId = item.GetAttribute("ID");
                if (int.Parse(itemType) == (int)ItemType.Page)
                {
                    //only include published pages.  we also exclude index pages
                    //because the parent structure group's URL will default to them.
                    if (bool.Parse(isPublished))
                    {
                        Page childPage = engine.GetObject(itemId) as Page;
                        if (!ShouldBeExcluded(childPage))
                        {
                            XmlElement pageElem = doc.CreateElement("siteMapNode", xmlns);
                            parent.AppendChild(pageElem);
                            pageElem.SetAttribute("url", childPage.PublishLocationUrl);
                            pageElem.SetAttribute("title", RemoveNumberPrefix(childPage.Title));
                        }
                    }
                }
                else
                {
                    log.Debug("sgId=" + itemId);
                    //if it's a structure group, then
                    //get the object, create a child sitemap node
                    StructureGroup childSg = engine.GetObject(itemId) as StructureGroup;
                    if (!ShouldBeExcluded(childSg))
                    {
                        XmlElement sgElem = doc.CreateElement("siteMapNode", xmlns);
                        parent.AppendChild(sgElem);
                        sgElem.SetAttribute("url", childSg.PublishLocationUrl);
                        sgElem.SetAttribute("title", RemoveNumberPrefix(childSg.Title));

                        GenerateSitemap(childSg, sgElem, doc);
                    }
                }
            }
            return doc;
        }

        ///
        ///

        /// Pages and Structure Groups are often named with a numeric prefix to help sort
        /// them in a particular order.  This prefix does not need to be included in the
        /// web.sitemap file, so we strip it out.
        /// 

        ///
        ///

        /// 
        private string RemoveNumberPrefix(string p)
        {
            string NUMBER_PREFIX_SEPARATOR = "_";
            return p.Substring(p.IndexOf(NUMBER_PREFIX_SEPARATOR) + 1);
        }

        ///
        ///

        /// This function checks if the page should be
        /// excluded from the sitemap. For example, it makes sense to filter
        /// out the index pages, since their parent structure group's url
        /// will point to them, and we don't want to include the index page
        /// twice.
        ///
        /// We also don't want to include user controls, i.e. ascx pages,
        /// so we'll filter those out too.
        /// 

        ///
        ///

        /// 
        private bool ShouldBeExcluded(Page page)
        {
            string url = page.PublishLocationUrl;
            string title = page.Title;

            //filter out user controls
            if (url.EndsWith("ascx") || url.EndsWith("sitemap"))
            {
                return true;
            }

            //filter out if index page
            string[] indexPageNames = new string[] {"index.html", "index.htm", "index.aspx", "default.aspx"};
            foreach (string indexName in indexPageNames)
                if (url.ToLower().EndsWith(indexName))
                {
                    return true;
                }

            return false;
        }

        ///
        ///

        /// It may make sense to exclude any structure groups that don't have any childen pages or other structure
        /// groups.
        /// 

        ///
        ///

        /// 
        private bool ShouldBeExcluded(StructureGroup sg)
        {
            Filter filter = new Filter();
            filter.Conditions["ItemType"] = ItemType.StructureGroup;
            filter.Conditions["Recursive"] = true;
            filter.BaseColumns = ListBaseColumns.Id;
            int pages = sg.GetListItems(filter).SelectNodes("*").Count;
            return pages == 0 ? true : false;
        }
    }
}

SDL Tridion webinar: Presentations and resources

John Winter — Wed, 11 Jan 2012 20:14:29 +0000

For anyone that would like the slides from today’s SDL Tridion community webinar here are the downloads:

Thanks Jules/SDL for having us and we’re looking forward to the next one.

SDL Tridion Application Integration

Nickoli Roussakov — Fri, 30 Dec 2011 07:13:06 +0000

When I first got the opportunity to work with Tridion, the biggest question I needed an answer to was how to integrate various applications with SDL Tridion. At the time, I was running a project that required migrating about 20 J2EE applications tightly integrated with a legacy Plumtree Portal to a .NET platform driven by SDL Tridion. The organization was moving away from J2EE to become a .NET shop, so the apps needed to be rewritten in .NET – our #1 task. All we had was a barebone Tridion installation and a bunch of manuals that did not mention anything about how to integrate apps into it. SDL Tridion training also did not cover this topic – although we got some useful hints, we needed to see a proven design. My intent with this article is to help any new Tridion teams to keep their project moving forward if faced with a similar situation.

The approaches discussed here are not limited to .NET. They can be leveraged to integrate Tridion content into J2EE apps, mobile apps, or anything that you want, such as PHP, Perl, C++. In other words, the sky is the limit.

First off, it is important to understand that Tridion offers two publishing models:

Static publishing: the Tridion Content Manager publishes content in the form of files to any location you wish via HTTP, FTP, NFS and others. For e.g. put a jsp file to an app server, or an aspx file to an IIS server in the DMZ.
Dynamic publishing: the Tridion Content Manager publishes content in the form of data to the Broker, which is an application configured on your presentation server. The published content in the Broker is accessed via an API. This is close to how integration works with other CMS or portal products, except that applications’ requests are not going across the entire firewall back to the Content Manager – which is sweet!

Application Integration with Dynamic Publishing Tutorial

If you’ve chosen to leverage the benefits that the Broker has to offer, i.e. option 2 above, then your app can simply use the functions from the Broker API to retrieve content from the Broker. If your app is Java-based, then simply include the Broker JAR files and set up some parameters in the web.xml. The same thing applies to a .NET app, except you’ll be including a DLL instead of the JAR and using the .NET version of the Broker API. Have a read through the Tridion Content Delivery Implementation Manual for the fine details. It’s easy after you have everything configured. The differences between the Java and the .Net versions of the API are just syntax. All the methods and classes are pretty much the same.

For those that are new to the Tridion architecture, remember, your app does not query the Content Manager directly like it does in most other products out there such as the Oracle UCM, Sharepoint or the legacy Plumtree Portal. With SDL Tridion, content management is separate from the published content. So our apps query the published content in the Broker via the Broker API, which is a separate data store from the Content Manager. You can, of course, make your app talk directly to the CM via the Business Connector or Custom Pages if you have a proper reason to do that, but if you just need to pull some content in an externally-facing app, then Broker is the tool to use.

Application Integration with Static Publishing Tutorial

This is my favourite because of its simplicity – less infrastructure and easy to transition, maintain and in general understand.

On that project which I mentioned in the intro, the mandate from Enterprise Architecture was that, if possible, systems should be loosely integrated without building too much dependency on one particular product. This means favouring web services over proprietary product API calls inside other systems, as one example. Loose integration makes it easier to swap systems if introducing another product in the middle or upgrading to a different product. At an Enterprise Architecture level, it’s a great strategy to manage technical risk from the point of view that Enterprise IT system’s average life span is 5-10 years. So if a system isn’t meeting your expectations or growing requirements, it’s cheaper and easier to upgrade or replace it when loosely integrated. I had the pleasure of experiencing the opposite by having to re-factor many applications when a client of mine switched from the old Plumtree portal to Sharepoint (for internal apps) or Tridion (for external). Of course there are cons to the Static over the Dynamic publishing approach, but I’m not going to get into further debate on this here.

As mentioned, with the Static Publishing model, files get published out to a server location. These files can be of any kind – jsp, include, aspx, ascx, xml, php, and so on. You create a Page Template where you can specify any file extension that you choose. What does this mean?

It means that you can publish out chunks of content as separate “include” pages with all the HTML markup or logic, and your apps simply consume them. You can also create a Page Template that will render and publish out XML (in the format you chose – refer to Dreamweaver Templating), and your app can consume it by parsing and rendering it. You can also make the Page Template render the content with HTML markup inside an XML CDATA field. Once again, the sky is the limit.

Example: Integration with a Custom .NET App

Here is an example where promotional content is managed in Tridion, such as widgets and call-to-actions, and an ASP.NET-based user registration system needs to display this content as right rail widgets.

Seems like a User Control would be perfect for the job. (BTW, if you’re integrating with Sharepoint, then a Web Part could be used just the same.) Our user registration system can wonderfully render this User Control in the right rail of its ASPX page.

Step 1: Create a User Control Component Template

Suppose you have a Promo schema with fields such as: ‘title’, ‘promo page url’, ‘promo image’, and “promo text”. Through the magic of Tridion’s Compound Templating we create a Tridion Component Template, “Right Rail CT”, which contains a Dreamweaver template TBB that looks something like this (let’s assume all the fields are mandatory for simplicity’s sake and avoid TemplateBeginIf’s):




     
     @@Component.promoText@@

Step 2: Create a User Control Page Template

Let’s call this “Right Rail Promo User Control PT”. The file extension for pages generated by this template is “.ascx”. It is a very simple template that renders our Promo items using the “Right Rail CT” as User Controls:


<%@ Control Language="C#" ClassName="contentbloom" %>


@@RenderComponentPresentations()@@

Step 3: Create and Publish the User Controls

Now you can create various Promo Right Rail Widget User Controls as Tridion pages and publish them. Simply create a new Tridion page in a Structure Group such as “/usercontrols/promos/”, and in it create pages using the “Right Rail Promo User Control PT” template. Now simply publish it to the same IIS server(s) on which our application is hosted.

Step 4: Consume the User Controls by the Application

Our .NET-based New User Registration application can now include the published user controls on the right rail of its ASPX or Master pages. It’s pure .NET at this point. The application’s ASPX page would have a statement like this in its right rail div:


<%@ Page Language="C#" %>

User Registration Step 1


      
    

        <%@ Register TagPrefix="contentbloom" TagName="RightRailPromoWidget1" Src="/usercontrols/promos/promo1.ascx">

Bullet-proofing (optional)

I like to put in a little bit of bullet-proofing into the application’s logic, so that if a user control is unpublished, the application doesn’t throw a 500 error since it can’t find it. We do this by loading the user controls into the right-rail div programatically from the code-behind (or inline):

Check this out:

user-registration-step1.aspx:



<%@ Page Language="C#" %>






User Registration Step 1

Now the page will attempt to load the right rail promo user controls, but if they’re not available or not needed, then the page continues to load normally without them. This could greatly reduce the likelihood of a severity 1 production issue because a content editor decided to unpublish a certain promo.

JavaScript Compression in SDL Tridion (minification and obfuscation. CSS too)

Nickoli Roussakov — Tue, 20 Dec 2011 01:44:47 +0000

I’ve been building up my jot notes throughout the year and finally got the chance to make them into publishable form, which lead me to this sudden series of articles. Thanks, John, for letting me post on your site.

To achieve maximum compression on a JavaScript file, minification is not enough. Obfuscation is where it’s at. This means replacing variable names to the shortest amount of characters (or bytes) that the language syntax allows. For example: var myReallyLongVariableName=”foobar” would become var a=”foobar”; but only within its scope, and so on. You basically have to implement a decent chunk of code that usually comes as part of any language interpreter or compiler. It’s quite a bit more involved than minification alone. My point is, use a proven package that does this and just hook it up to the best CMS known to man.

My preferred way is actually to not store JavaScript or CSS in Tridion. Put it with the rest of your website’s code into the repository like TFS or Subversion. Basically, bundle it into your build process which should go through Change Management with the likes of JAR/DLL files and DB packages. JS is code after all. This way you can just add a step to your build process. Ask the build master to crunch the JS/CSS through a compressor (possibly as a manual step) before or automate within an ANT, NANT or MSBuild script. If, however, you are a content author or Support person that hates dealing with your org’s Change Management process or have some other reason to store js and/or CSS code as easily publishable as content, then this is for you.

A requirement I often get requests for is to minify and obfuscate JS files which are stored in Tridion, either in Multimedia Components or pasted into a text field of a normal component. Minification is trivial. Simply remove the extra whitespace and comments. Obfuscation, however, is a bit more involved as I mentioned above. So let’s find a good JS compressor package that’s available today.

YUI Compressor is the best minification and obfuscation library that is out there. It was created by engineers at Yahoo!. Since the original package is in Java, but Tridion templating is done in C#, we’ll turn to the YUI Compressor .NET port (link is below).

There are two classes with methods that do what we need to do:

CSSCompressor.Compress(string)
JavaScriptCompressor.Compress(string)

Both of the above return string. So all we need to do is extract the CSS or JavaScript content from our component as a string, call the YUI Compressor methods and publish the CSS or JS file.

There are a few ways that a CSS/JS file can be published:

1) Static publishing model – the component holding the JS is added to a Page and published (using a simple page template). Our fellow Tridion community member, Jonathan Whiteside, has an excellent article series that dives into these details in his discussion on Tridion CSS Minification (http://blog.building-blocks.com/2011/01/tridion-tbb-automatically-minify-css-javascript-on-publish).

2) Dynamic publishing model – the component is published via a dynamic component template that relies on a TBB which extracts the JS content from the component and calls the AddBinary method with a Structure Group URI as a parameter. No Page is necessary here, but you do need at least the file system Broker running.

My aim in this post is not to get into the details of #1 or #2 above. I will show an example that extracts the JS or CSS as a string from the MM Component (using Jonathan’s method), call on the YUI Compressor to obfuscate and minify, and place the compress string as a variable onto the Package. You can do whatever you wish with it at that point – put the TBB into a static or dynamic CT.

Here we go:

Download the .NET port of the YUI Compressor from here: http://yuicompressor.codeplex.com/
Take these DLLs and put them in the GAC or the Tridion Bin folder on your Content Manager server(s). Make sure these DLLs are on all the CM servers that the TBB will need to execute on (all load balanced CM nodes, Dev, QA, Prod, etc). Make sure to submit a Change Request to have these DLLs installed on anything past the Development environment, but if you have a good, no BS rep with your server admins (like I always do , this shouldn’t be a problem.
Make sure the Template Base class (which is part of Will’s Get Linked Components extension) is added into your Visual Studion project.

Create a new Template Building Block class in Visual Studio with this code:


using System;
using System.Text;
using System.Text.RegularExpressions;
using Tridion.ContentManager;
using Tridion.ContentManager.ContentManagement;
using Tridion.ContentManager.Templating;
using Tridion.ContentManager.Templating.Assembly;
using ContentBloom.Tridion.B2C.Templates.Base;
using System.IO;
using Yahoo.Yui.Compressor;
using System.Globalization;

namespace ContentBloom.Tridion.B2C.Templates
{
    [TcmTemplateTitle("Compress JS and CSS using YUI Compressor")]
    public class CompressYUI : TemplateBase
    {
        enum BinaryType
        {
            JS, CSS, Other
        }

        public override void Transform(Engine engine, Package package)
        {
            // Initialize
            Initialize(engine, package);
            string codeContent;

            // Get CSS Content
            Logger.Debug("Retrieving code from Component.");
            Component comp = this.GetComponent();
            string filename = Utilities.GetFilename(comp.BinaryContent.Filename);
            BinaryType bt = GetFileType(filename);
            if(bt == BinaryType.JS || bt == BinaryType.CSS)
            {
                string needsCompression = package.EvaluateExpression("Component.Metadata.compress");
                // if the "Compress" field is not specified, then default it to True.
                if (string.IsNullOrEmpty(needsCompression) || needsCompression == "True")
                {
                    codeContent = GetCodeContent(comp);

                    try
                    {
                        Logger.Debug("Before minification:\n" + codeContent);
                        switch (bt)
                        {
                            case BinaryType.CSS:
                                codeContent = CssCompressor.Compress(codeContent);
                                break;
                            case BinaryType.JS:
                                codeContent = JavaScriptCompressor.Compress(codeContent, true, true, false, false, -1, Encoding.UTF8, new CultureInfo("en-US", false));
                                break;
                        }
                        Logger.Debug("After minification:\n" + codeContent);
                    }
                    catch (Exception e)
                    {
                        string message = e.Message;
                        if (e.Message.Contains("syntax error"))
                        {
                            message = "There is a problem with the encoding of the file. Please change the encoding of the file to UTF-8 WITH NO BYTE ORDER MARK/UTF-8 without signature.";
                        }
                        throw new InvalidDataException(message, e);
                    }

                    //push to Output.
                    package.PushItem("Output", package.CreateStringItem(ContentType.Text, componentCount.ToString(codeContent)));
                }
                else
                {
                    Logger.Info("Component metadata \"Compress\" field specifies to avoid compression. Therefore, exiting.");
                }
            }
            else
            {
                Logger.Info("No CSS or JS file found, so nothing to do.");
            }
        }

        private BinaryType GetFileType(string filename)
        {
            Logger.Debug("Entering method GetFileType");
            BinaryType bt = BinaryType.Other;
            filename = filename.ToLower();
            Logger.Debug("filename=" + filename);
            if (filename.EndsWith(".css"))
            {
                bt = BinaryType.CSS;
            }
            else if (filename.EndsWith(".js"))
            {
                bt = BinaryType.JS;
            }
            Logger.Debug("Exiting method GetFileType");
            return bt;
        }

        ///
        /// Get the CSS content in plain text from the current component
        ///
        /// CSS content in plain text
        private string GetCodeContent(Component c)
        {
            // code path
            string codeContent = string.Empty;

            // read the css into a string
            UTF8Encoding encoding = new UTF8Encoding();
            byte[] binary = c.BinaryContent.GetByteArray();
            if (binary != null) codeContent = encoding.GetString(binary, 0, binary.Length);

            return codeContent;
        }
    }
}

Finally, add the TBB to your Component Template and enjoy the sexiest minified and obfuscated JavaScript.

Minify/Obfuscate Only on Demand

You can go one step further and add a bit of logic to minify and obfuscate only for certain scripts, e.g. obfuscate one, but not the other. Here’s what you can do…

In your JavaScript Multimedia Component schema add a couple of Text metadata fields:

Field name: “Minify”. Value: Select from Dropdown “Yes/No”.
Field name: “Obfuscate”. Value: Select from Dropdown “Yes/No”.

Modify the TBB above to read these fields from the Component and minify/obfuscate accordingly.

More fun with Dreamweaver Templates – TemplateRepeatCount

Nickoli Roussakov — Sun, 18 Dec 2011 05:08:43 +0000

Quite a while back (in ’09′ I think) I replied to a thread on the sdltridionworld forum regaring how to get the total count of your elements when doing a TemplateBeginRepeat inside a DWT.

For example when you have a special css class that needs to be applied to the last item in the list.



Contact Us
Site Map

An intuitive approach is to have a function or a variable that provides the count so that you can use syntax like this:



 
@@MyUrlText@@

  
@@MyUrlText@@

I’ll post that function later once I dig up the code again. Though, here is another approach which I used one late night in the office wanting to finish a template. It was past my sys admin’s office time, so I couldn’t ask him to deploy a new Custom Functions DLL to the CM server’s GAC/bin, but I just had to get the template done by end of day – I was in the zone. Besides, I couldn’t let it linger the next day.

So here is a quick C# fragment that should be used in sequence after Will Price’s “Get Linked Components” extension (just Google it if you don’t know. It’s the best thing since the combustion engine/sliced bread/eh…SDL Tridion CMS).

Anyway, just drop this C# Fragment in after “Get Linked Components”:


<%@ Import Namespace="Tridion.ContentManager.ContentManagement.Fields"%>
<%@ Import Namespace="System.Collections.Generic"%>

/// This TBB loops through all the items in the package and for any items which are Component Arrays
/// adds a new package item with the array entry count.  This is useful when a Dreamweaver TBB needs to know
/// the total count of components or when needing to know if you're on the last component.

List> extractedComponentLists = new List>();
foreach (KeyValuePair kvp in package.GetEntries())
{
    if (kvp.Value.ContentType == ContentType.ComponentArray)
    {
        //get count
        extractedComponentLists.Add(kvp);
    }
}

// This code has to be kept in a separate loop since you can't modify the package.GetEntries collection while looping through it.
foreach (KeyValuePair kvp in extractedComponentLists)
{
    IComponentPresentationList linkCollectionCPList = ComponentPresentationList.FromXml(kvp.Value.GetAsString());
    int componentCount = linkCollectionCPList.Count;
    package.PushItem(kvp.Key + "Count", package.CreateStringItem(ContentType.Number, componentCount.ToString()));
}

After this TBB runs, you’ll get a new entry on the package with the count for each “Tridion/Component[]” item type that “Get Linked Components” fetches. So if we had a multi-value component link field in the component called “LinkList”, then “Get Linked Components” should fetch a component array and call it after your field name – something like “LinkList”. Then after this DWT a new entry will appear called “LinkListCount”.

Use it like this in your DWT:




@@MyUrlText@@
 
@@MyUrlText@@

Get and Set Variables in DWTs

Nickoli Roussakov — Sat, 17 Dec 2011 00:22:38 +0000

Here is a creative and useful set of Dreamweaver Custom Functions that allow instantiating your own variables in a Dreamweaver Tridion template. Credit goes out to my fellow team members Trevor Bartlett and Riyaz Hameed.

You can do stuff like this:



  
    
      
@@Field.title@@
    @@SetVariable(“columnSectionIndex”, "${TemplateRepeatIndex}")@@
    
    @@GetVariable("columnSectionIndex")@@
    
       …
    
  


Here is the code:

/// 
/// Sets a varialbe in the package to the name and value specifed. Also removes any other variable that was set with the same name before.
/// 
/// Name of the varialbet
/// Value of the variable
[TemplateCallable()]
public string SetVariable(string variableName, object value)
{
    //Remove the old variable and set the new variable
    _engine.PublishingContext.RenderContext.ContextVariables.Remove(variableName);
    _engine.PublishingContext.RenderContext.ContextVariables.Add(variableName, value);

    return "";
}

/// 
/// Gets a varialbe from the publishing context.
/// 
/// Name of the variable
[TemplateCallable()]
public object GetVariable(string variableName)
{
    //Get the varialbe
    return _engine.PublishingContext.RenderContext.ContextVariables[variableName];
}

Getting used items using the core service

John Winter — Sun, 27 Nov 2011 18:52:11 +0000

Just wanted to post up a quick code snippet showing how to get a list of used items XML using the SDL Tridion 2011 core service. Why? Well previously the API typically used to work like itemType.GetListUsedItems() (where itemType is a Component or Page object etc), where as now the ‘Using’ and ‘Used’ items are read using a filter via the core service client method .GetListXML().

The example:


            // Create a filter
            UsedItemsFilterData usingItemsFilterData = new UsedItemsFilterData
            {
                BaseColumns = ListBaseColumns.Id, // to specify the detail in the XML
                ItemTypes = new[] { ItemType.Folder, ItemType.Schema, ItemType }  // to specify certain items
            };
            // Get the XML by calling .GetListXml on the client (assumes you have a 'client' object already)
            XElement usingXML = client.GetListXml("tcm:4-283", usingItemsFilterData);

If you’re looking to get the Using Items, for an item, you can simply use a UsingItemsFilterData filter in exactly the same way – enjoy

Integration: SDL Tridion & JW Media Player

Nickoli Roussakov — Wed, 09 Nov 2011 13:22:11 +0000

Often clients have a need to embed videos within their rich text content fields of various formats (FLV, mp4 or streaming via RTMP). Pasting video embed code is one way to deal with this, the video and it’s dependant files need would to be published separately in Tridion with the video URL hardcoded as part of the content. This is not an elegant, nor a user-friendly solution.

The JW Player Video Renderer module allows the non-technical user to include a video Multimedia Component as a Component Link within their rich text field. All that is required is a little bit of configuration and a TBB.

Here is the code: Tridion JW Vide0 Renderer.zip

And the document that explains it all: JW Video Player Tridion Integration.pdf

Remove HTML whitespace from the template output

John Winter — Mon, 10 Oct 2011 23:54:03 +0000

HTML published from Tridion is typically created using Tridion Dreamweaver Templates (DWTs). These templates can involve a lot of ‘If’ statements to check that values exist or what their value is etc. I like to put line breaks between each DWT statement so that its easier to read and work with, which usually looks something like this (actually it can get a lot crazier than this!):

The only issue with doing this is that HTML white-space is preserved, resulting in tonnes of extra line breaks in the published HTML. I’m anal about HTML, (there will be NO extra line breaks, NOT ON MY WATCH!) so I wrote a little TBB to clean up any lines that are blank, here’s the code:


        public override void Transform(Engine engine, Package package)
        {
            this.Initialize(engine, package);

            //get output item from the package
            string outputName = Package.OutputName;
            Item outputItem = package.GetByName(outputName);

            // if the output is text based, lets clean it up
           if ((outputItem.Type == PackageItemType.String))
            {
                Logger.Debug("Output exists, cleaning empty lines");
                string uglyOutput = outputItem.GetAsString();

                //Gets the converted output string
                string fixedOutput = Regex.Replace(uglyOutput, @"^\s*$\n", string.Empty, RegexOptions.Multiline);
                //Remove the old output string, and put the new one in place
                Logger.Debug("Output cleaned, updating item in package");
                package.Remove(outputItem);
                outputItem.SetAsString(fixedOutput);
                package.PushItem(outputName, outputItem);
            }
        }

The usual caveat about the code published here is that it is using the SDL Tridion base classes