Tridion Developer » Helpful Tridion tips

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!

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

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

Online SDL Tridion resources

John Winter — Fri, 05 Aug 2011 11:37:49 +0000

In the past couple of months a number of great online resources have popped up to help with SDL Tridion development, implementation topics and environment configuration. These links are mostly promoted on Twitter, so in the event you have missed them, I’ve made a compilation of some favourites.

SDL Tridion 2011 online documentation
SDL’s own online documentation covers everything from installation of the CME, Content Delivery (very useful as major changes have been made in 2011), upgrading, GUI extensions, Smart Target, Translation Manager and the new Online Marketing Explorer.

To access the system you may need to log in with the following details:
Username: visitor
Password: sdltridion

SDL Tridion World
There have been tonnes of new posts to SDL Tridion world since the release of 2011. Including step by step guides for some of the new features, including setting up the new 0Data service and configuring your own GUI Extension.

Rainmaker’s Tridion /.Net MVC
Kah Tang has placed a sample .NET MVC project online. The project uses content via Tridion’s Dynamic Delivery. Worth checking out not only for the MVC, but as an example of .NET using Tridion broker content.

Building Blocks Blog
The building blocks team have created some great examples showing how to use the new Core service for creating and importing content into Tridion.

SDL Tridion community posts
A number of great posts have come out of the SDL Tridion community including:
Nuno Linhares: Manually configuring a Tridion 2011 .NET Content Deployer Instance
Yoav Niran: Tonnes of great GUI extensions and tutorials
Walter Van Der Heiden: Using SDL Tridion to generate QR codes
Steve Sidell: SDL SmartTarget: Delivering advanced targeting, profiling and personalization tools

Tridion Practice Cookbook
Recently set up by Dominic Cronin the Tridion practice cookbook to not only show how to implement SDL Tridion features, but how features can/should be coded, it’s a great initiative and I hope it catches on within the community.

I hope I’ve not missed anything off, if so please let me know in the comments.

GetObject vs Get(ItemType)

John Winter — Thu, 14 Oct 2010 16:26:48 +0000

This is more of a ‘note to self’ as I’m constantly being caught out when getting an object from Tridion using the various TDSE methods.

I’ll use the example of getting a folder via the TDSE object. To do this you have two ways:

The TDSE.GetFolder(“ID”, Publication Object) Method
The TDSE.GetObject(“ID”, OpenMode, Publication, ReadFilter) Method

The GetFolder will always need a valid Publication object, where as the GetObject will allow a null to be thrown in.

I’ve done this a thousand times:

TDSE.GetFolder(“tcm:1-123-2”, null);

Then spent about 20 minutes checking the XML, the webdav etc etc.

The benefit of being able to pass the null, is that if the Publication object doesn’t exist, you don’t have to create it surely making the GetObject a far superior method to use… just remember to cast to the correct Tridion item type:

Folder fld = tdse.GetObject(…) as Folder

Please tell me I’m not alone in being constantly caught out by this!

Displaying item XML in the GUI with interface extensions

John Winter — Mon, 06 Sep 2010 15:37:40 +0000

Yoav Niran has written and blogged about another great Tridion GUI extension. This time providing a really elegant solution for developers/users that need to see the full XML content of an given item without having to (in my case) faff about with ID’s, Paths or templates.

I can’t think of any project where at some point in the build I’ve needed to check the item’s XML, usually to get a path, check check security or some other content related detail.

My solutions to this have varied depending on the situation:

A custom template – A small bit of code as a Tridion page template, where the TCM is added directly into the code, which is going into the Tridion database and returns XML. Essentially update the code with the new TCMID and preview the page. This is fine but it’s a bit slow in terms of updating and previewing.

Webdav - Great, but this only works when you want to view components, schema and templates.

Using the windows run menu – Entering the item TCM ID in the windows run menu will bring back the given items XML, this is great, but only works if you’re on the actual CM machine.

Thanks Yoav’s, this is a fantastic solution, plus all of the above are now redundant!

What would be cool if these could be part of the installed GUI with configurable security to only show this to members of a certain group and to hide from others that simply don’t need it.

Some notes about Tridion item naming

John Winter — Wed, 31 Mar 2010 16:02:15 +0000

I’ve just recently written a script which imported a load of content from flat files into Tridion. Using the flat files, the script creates the various folders, pages and components etc that it needed. Unfortunately I cannot share the code as the client contract permits me to do (plus it was a throw-away tool written specifically around the format of the import data) but I can share a couple of titbits that I learnt about item naming and WebDAV lengths.

Note: All of the below are tests performed in Tridion 2009.

Item naming.
The following rules are present:

The CMS GUI will not let you enter more than 250 characters when naming (the item Title field) Publications, Folders, Components and Structure groups. This also applied to the Structure Group “directory” field.

I found the page ‘Title’ field has a little quirk when naming as the GUI will allow an infinite number of characters however, if you enter more than 255, you will receive an error message like the one below:

The page ‘Filename’ follows the normal convention of only allowing a user to enter 250 characters.

Tridion will allow most special characters, with the exception of “/” but I wouldn’t recommend ever using special characters as this will only lead to problems later in life J

If you simply must have special chars in your naming this post may help you should you ever need to obtain such items using WebDav.

WebDAV paths.
The maximum length of a WedDAV path (on the system tested) is 300 characters. Which means it is very easy to exceed this limit with a combination of long folder names and a deep folder structure.

The best advice is to keep all naming as short as possible and again avoid special characters.

Final note, I’ve only experimented with the items mentioned above, but I’m sure the same rules apply to items such as Page & Component templates etc.