Why Tridion ? (Part 2 : The Right Choice)

SDL Tridion (aka SDL Web 8) being one of the leading web content management system has some edges over its other competitors for a long time.

In the previous part, we have seen the strategies behind selecting any cms and here we will see how do we identify the right choice for the customer.

Mostly this concerns comes up when one need to opt for one CMS (all want the best though) and other is when there is a question on migration or version update.

Why we need to compare the CMS products?   Since we know what is the best in the market….

A tool X can be best fit for Customer ‘A’ but may not be the one for Customer ‘B’, it requires proper analysis on facts like how many sites they have, how many languages do they support, who are their business users, what are the channels they want to have for marketing their content etc. etc.

The reason for performing a  comparative study of various CMS’s available in market is to be ready for any market changes , technology upgrade or a need to change platform. We will see based on what parameters a proactive counseling can be done for best selection of CMS as per any customer needs or change/ upgrade to a new CMS. This R&D is being performed keeping two aspects in mind : Technical and Functional. You can always add/remove parameters if you think that is needed and let me know if i have missed important ones.

I have excluded other tools as it may vary in your case based on the language (.net/java/php) or the customer needs. I have listed standard technical and functional aspects for SDL Tridion 2013 and Web 8 only, you can add other tools while doing the actual comparison.

The Technical Parameters:

The Functional Parameters:

As per the analysis done based on the parameters, it seems  SDL Tridion/ Web 8 is the one with all required features included. Among other licensed tools, Adobe CQ5,  Sitecore, EPI Server, OpenText, IBM Portal Server are close.

Tridion, A right Choice, Indeed!!

Tridion seems to be the best fit as it supports multiple languages and multiple channels, when you have many a sites to be managed. It supports both Java and .Net platforms which makes it more flexible. Multiple delivery end frameworks (open source) are extensible as per the need and huge no of add-ons /power tools/ extensions are available which speed up the CMS functionalities.

But, choosing a CMS for any customer needs proper understanding of their actual need, where a CMS can be plugged in to solve their existing problems or new setup to achieve their goal in best possible way. Hope this article will give you in understanding your business cases and If Tridion is the right choice for your customer or not.

Happy Reading !!

Why Tridion ? (Part 1 : The 12’S !!)

A content management system (CMS) is an application that will help in creating, editing and managing the content, digital content or media. Here content could be text, images, video, documents etc.

A CMS typically based on the following applicability:
 ‘One CMS’ tactics by managing content of multiple websites or an enterprise in a centralized System.
 Create Read, Update, and Delete (CRUD) operation on content.
 Changing content of the website having little knowledge about the internal process of deployment.

There are many (1500+) CMS systems are available of free and proprietary licensed.
Open Source CMS Tools: Drupal, Joomla, Liferay, Alfresco, Magnolia, Hippo, Umbraco, Orchard, DNN and many more. Most of them are having community editions.
Licensed CMS Tools: SDL Tridion, SharePoint, Adobe CQ5, Sitecore, SiteInfinity, OpenText Web etc.

A CMS or WCMS will not only help in designing web pages through pre-installed templates (so no coding necessary in case no customizations is needed), and help publish content for everyone to see and use. It will also tell exactly which pages have been added or edited, when they were added or edited, and by whom.

So, before choosing any CMS for fresh installation or upgrade we must perform some analysis from our end (In my case It is for a SDL Web 8 upgrade)

What are the strategies behind selecting any CMS Tool? I have identified some key parameters and i call them the 12’S.Let’s see what are these 12’S ?

It can be called as THE 12’S (Strategies) for choosing any CMS based solution for easy retention. There are many more aspects that could be added in the list like ecommerce integrations, RSS Feed integrations, cost involved in the set up etc.

Let’s check what these strategies actually signify:
 ‘Shift Content Fast’ – add/update/delete content in a user friendly way and fast.

 ‘Single Content Repository’- have a centralized control on content change for all websites.

 ‘Secure Content Model‘- categorized content and ability to assign it to different personnel with security components in place.

 ‘Simple to play with website content’ – no deep technical knowledge and infrastructure details required to use.

 ‘Sustenance for document & media management’- it should support a degree of document management.

 ‘Sites in Multi Languages’- it should support websites in multiple languages.

 ‘Supply content to Multi Channels’- websites should have different device support (desktop/mobile)

 ‘System Integrations’- easy to integrate with (at least) some of the main applications, such as Outlook. Also Platform independent allows leveraging current technical expertise of team.

 ‘Sticking Extensions for customizations’ –extensions and plug in for customizations and CMS feature speed up.

 ‘Storing Versions of content’ – version management of content with maximum information.

 ‘Synchronizing Environments with same content’ – easy content synchronization in all environments (Dev, Test, Stage, and Prod).

 ‘Set up Analytics’ – Easy and maximum support for setting up analytics and SEO optimizations

If customer has a website, mobile app or other online presence then they need a WCMS to market and present their content in a customized, effective way. Choose a tool whose technology, vision and expertise most closely matches to their requirements.

Selecting a WCMS can be confusing, especially if the focus is too much on features. A better approach is to think about precisely what the business needs, now and in the future, and ensure that the selected WCMS meets the needs of each type of user.

Again, it completely depends on what the customer needs and how the selected CMS can be the best fit for them among all available CMS tools in the market.

So, in the next post we will see a comparative study based on identified functional and technical parameters and the possible outcome of the research which will help us to choose the best CMS fit for any customer based on their needs.

Happy Reading !!

SDL WEB 8 Upgrade Roadmap

Recently, for one of our client we tried to convince them for upgrading to SDL WEB 8 as they were looking for a change and we took the opportunity to guide them through for the best cms tool fit for them. Things both parties  were concerned about is current solution in place for customer, what are future needs and changes for them in 2016 and hence what steps are envisaged to be taken to keep the customer successful.

THE ROADMAP (SDL Tridion 2013 – SDL Web 8)

During the analysis, we will find answers to  :

 WHAT was in place for Customer currently?
 WHY Customer will change its Infrastructure in future?
 HOW we (vendor) can help to meet the expectations?
 WHERE are the key challenges and risks?

I have created one sample presentation which you can use with your customer specific content and also modifying as and where needed !!

SlideShare Link to the PPT

You can check & download the slides from the below link also !!

sdl-web-8-upgrade-road-map-template_Anupam

In near future, I will publish another article on “CMS Product Comparisons and Why Tridion ??” which was referred as the R&D conducted on different tools available in the market for reference.

I just want to share my experience and involvement in the process which may help you in identifying your case as well. And you may need help from your BA people to go ahead with your ideas and map them with customer’s need on the functional front. In my case, it was easy to convince since our customer were using Tridion 2013 but even if for a different CMS to WEB 8 migration can be proposed and executed with proper analysis and convincing points so that your Customer remains competitive in the market.

The idea is to keep you and your customer aware of the new changes SDL is making and by opting the correct tool at correct time they can exceed in their goals for the correct price !!

Any suggestions are mostly welcome !!

Content Movement Across Tridion Publications in Same Server

Recently my team has faced a scenario while porting items from one environment to another. The problem was all pages were in Y publication, which was the web publication in source server. But suddenly due to some changes (Blueprinting model behavior in destination,  which was not known to us) all pages and structure groups needed to be moved one level up in the structure, say in Publication X. We needed to move 40 items but the solution is applicable more when you have large no of items.

Now, X is parent publication of Y and there we face the challenge and we also know Tridion do not support across publication content movement (copy paste).

So, immediately we though of some automation to be in place and found similar things can be achieved using core service but we did not have time to built any rather if there is any existing tool/program for this kind of scenario would be more appropriate in the given timeline.

‘Content Porter‘ – Yes, you heard it right it can be done using content porter tool (some hints were available on the net).

Steps to be followed if we need to move content from publication X to publication Y, which is indeed parent to the previous.

Creating Export using Content Porter:

1. First Rename the source publication (i.e. X) name and publication key to the destination (i.e. Y) publication name and key. Before this step you will have to rename your destination publication’s name and key to any temporary value.
2. Create export zip of the items you want using content porter (from the renamed source publication)

Make sure you have selected correct options: (following worked for my case)

Import content using Content Porter:

1. Change back the publication name and key for both source and destination.
2. Import content from the created export package 
3. If you are in same situation like us i.e. Destination publication is parent of Source publication, then to avoid any issues while importing make sure to check the option “Selected children only”.
4. Check your CME for a successful import, do refer to cp_log if you face any issues.

We have faced one issue like “name and directory should be unique”, for that we have created a new directory and put all items there and then exported. After importing the new directory (renamed the one already existing) with all items, we have moved the content to desired directories and then have deleted all unnecessary or unused items.

In case, your source publication is a web publication and items are pages/SGs,

• Please make sure you unpublish the pages/SGs from old location.
• Rename /remove the parent SGs from old location (preferable keep a backup and remove all items once tested the new content).
• Publish the new items from web publication (inherited from the destination publication where we have make the import).

Hope this helps you to solve this kind of tricky problems !!

 

Tridion CoreServiceClient Provider (GitHub)

We often need to use Core service to perform different actions on CME end from our content delivery i.e. web application side.Now to make the life a little easier, I have created one class library to speed up the process with some generic and useful helper methods in build.

What is CoreServiceClientProvider?

It is a class library with support to all type of bindings for core service. It actually makes developer’s life easy in terms of setting up Core Service Client in Content Delivery / Web Application end.

Benefits of CoreServiceClientProvider

• It helps to setup core service client easily in your web application end.
• Speed up the process and make developer’s life easier
• Dynamically designed with configurable options to cope up with different types of endpoints supported for Core service.
• In built helper methods to address basic use of Core Service
• Customizable and reusability is another aspect.
• Can be used in any type of application (custom tools) which seeks information from CME end and Core Service is the way out.

CoreServiceClientProvider Library 

Just to add Following are some Helper Methods, i have included (all in one place) and will add some more helpful methods to make the library more useful.

• CreateKeywordsInCategory – Create keyword in a given category
• GetAllItemsInPublication – Get all items in any given publication
• GetTemplatesInPublication – Get all templates in any given publication
• GetPublishingTargets – Get publishing targets in any publication
• CreateBundle – Create bundle from given schema id
• UpdateSchemaForComponent – Already available, updates schema for any component
• SetPageFilterCriterias –  Sets Page filter criteria
• SetTemplateFilterCriterias – Sets Template filter criteria
• SetComponenetFilterCriterias – Sets Component filter criteria

Apart from these, there is an app.cofig file which needs to be added in your application, if you already have one then copy paste the details in the specified sections.

Within <appSettings> specify

• BindingName (default to: “wsHttp”)
• Domain Name (default to: Windows login)
• Username (default to: Windows login)
• Password (default to: Windows login)

Within <bindings> specify

• Details of different types of bindings you need (the name used in previous section)

 
Within <client> specify

• Details of endpoint address, binding name & configuration, binding type, contract

Setting up the CoreServiceClientProvider

It will take 5 minutes to set up the CoreServiceClient Provider in your application (will be treated as the client host) if you have the following information ready with you: (pre-requisites)

1. Your Core Service’s End Point URL
2. Domain name, username, password (if applicable). Else windows login will be used as default.
3. You have a reference to the following namespace in your application:

         Tridion.ContentManager.CoreService.Client

Steps to configure CoreServiceClientProvider:

1. Download the visual studio solution (complete project/zip file) from the below Github url: 
   Github project url

2. Add the project reference in your application/solution(you can add the class library also)
3. Download the App.config file from the following location:  
   Github
4. Copy and place the App.config file in your application (your existing application which will act as core service client host) root. Now, if App.cofing exists in your solution then copy paste the details in the specified locations, be careful while copying.
5. Made changes in the config file as mentioned above.
6. Build the solution.

Now, you should be able to use the different methods (in built) and if needed you can customize it.

Hope this will help the developers to set up the core service easily for using it for different purpose. This should be working for any DD4T and DXA based applications (.NET).  I will add some more helper methods going forward to make it more useful. You can post / reply to this blog with any ideas you have to make the solution better, any suggestions are mostly welcome.

Happy Coding!!

Considering Points for DD4T based Applications

Considering Points for DD4T based application using Tridion version?? (2013 /Web 8)

Assuming Webpage is the final outcome, Items used in the page could be of three types:

1. Individual Items (Component Views mainly)
2. Shared Items (Page views / Navigation Items)
3. CME TBBs / Extensions (TBBs / Content / Templates/ Schemas)
4. Any external app??

Complexity could be of four types: Simple, Medium, Complex and Very Complex.

Following are the considering points to define the Complexity of items:

1. How many type of Page customer has or want to have? This will lead to no of page views – Simple / Medium

• Page views hold overall layout (html), Section discrimination is done here
• Has reference to your base layout, script bundles, header, breadcrumb, left navigation, content template (CTs), footer etc.
• How many component views are rendered/supported in each page view?

2. Component Views are content with business logic – Complex / Very Complex

• Site Edit Feature (XPM) enabled for all content from Tridion (needs blueprint and schemas to be designed first to determine what can be put in CM)
• Amount of Content, Helper methods (if any) for rendering contents (RTF, Link components/ Dynamic Component/ Broker service call)
• Service / DB (customer/broker) calls, mapping (business logic??)
• Partial views (based on business logic) to be designed for each Component

3. Navigations Items – Complex

• TBBs in CM end (navigation xml / sitemap xml), Logic in Web app end to render the content from broker and create the navigation (any custom business logic in navigation better to be handled in CD end if using DD4T)
• Design and Development of all navigations items
• Pre login / Post login navigations same or different (if applicable)

4. Any OOB Feature (CM /CD End) – Very Complex

5. Front end HTML design – Based on your expertise and size

• Html 5 / Bootstrap / or any?
• JQuery / Data table / Scripts/ Flash/ Validations (forms or any)?
• Style classes (How much and what type of)?

6. Multi-Channel Support – What are devices to be supported?

• Device specific html / views? This will be challenging but easy to manage
• Same views rendered in different devices (Code / Html/Styles) customization? Easy to design but difficult to maintain

Apart from these things to be considered are:

7. No Of pages (Page views/component views), Amount of content to be shown in each page (no of Component and Schemas)
8. Multi language / Multi device support?
9. Existing Site or new? (If existing scope for reusing business logic code or validations or look and feel??)
10. Team’s strength/knowledge on the technologies/tools will be used

**If Using SDL Web 8, see the new features can be included or not (Topology manager, Business Process types, Discovery and Content Interaction services etc.), it is mostly supported with the framework DXA (more or less same as of DD4T 2.0) for both Java and .Net.

Hope this helps you identify complexities for each and every module for designing the website using DD4T with some modifications, this helped me in projects estimation phase. Any suggestions are mostly welcome !!

Tridion Utility Methods (DD4T)

Tridion Utility / Helper Methods

We often faced scenarios for which we need to write helper methods to overcome business needs or application needs using Tridion with DD4T framework but mostly to work with other frameworks as well with some modifications.

Here we will see some standard helper methods which can used in most of the Tridion/.Net based projects.

Method 1:  Resolves the URL of the embedded component with in the component

public static string GetDynamicUrlFromComp(IComponent model, string key)
{
if (!model.Fields.ContainsKey(“components”)) return string.Empty;
var linkField = model.Fields[“components”].EmbeddedValues.FirstOrDefault(k => k[“key”].Value == key);
if (linkField == null) return string.Empty;
var linkedComponent1 = linkField[“value”].LinkedComponentValues[0];
return linkedComponent1. FetchUrlFromComponent();
}

 

Method 2:  Resolves the url for the current component via dynamic linking, if component is a multimedia component, then Multimedia.Url will be returned.

public static string FetchUrlFromComponent(this IComponent component, string sourcePageUri, string excludeComponentTemplateUri)
{
string linkResult;
if (component.Multimedia != null)
{
linkResult= component.Multimedia.Url;
}
else
{
if (string.IsNullOrEmpty(sourcePageUri) && string.IsNullOrEmpty(excludeComponentTemplateUri))
{
linkResult= LinkFactory.ResolveLink(component.Id);
}
else
{
linkResult= LinkFactory.ResolveLink(sourcePageUri, component.Id, excludeComponentTemplateUri);
}
}
return linkResult;
}

Method 3: Creates an anchor link from the component field

/// <param name=”helper”>Renders HTML controls</param>
/// <param name=”link”>Component fileds with link</param>
/// <param name=”linkContent”> anchor link</param>
/// <returns>MVCHtml string</returns>

publicstatic MvcHtmlString GenerateLinkFromComponent(this HtmlHelper helper, IFieldSet links, string linkContent)
{
MvcHtmlString resultString = new MvcHtmlString(String.Empty);
String title, href, linkText, target, rel;
GetLinkFieldValues((IFieldSet)links, out title, out href, out linkDataText, out target, out rel);
if (string.IsNullOrEmpty(linkDataText) && string.IsNullOrEmpty(title) && string.IsNullOrEmpty(href) && string.IsNullOrEmpty(target))
{
resultString = new MvcHtmlString(linkContent);
}
else
{
TagBuilder anchor = new TagBuilder(“a”);
anchor.Attributes.Add(“href”, href);
anchor.Attributes.Add(“title”, title);
anchor.Attributes.Add(“target”, target);
if (!string.IsNullOrEmpty(linkContent))
anchor.SetInnerText(linkContent);
resultString = new MvcHtmlString(anchor.ToString());
}
return resultString ;
}

Method 4:  Get multiple details related to any type of link created in tridion  CM.

public static void GetLinkFieldValues(IFieldSet link, out string title, out string href, out string linkText, out string target, out string rel, bool addVerToInternalLink = false)
{
title = linkText = href = target = rel = string.Empty;
target = “_self”;
if (link.ContainsKey(“title”))
{
title = link[“title”].Value;
}
if (link.ContainsKey(“Title”))
{
title = link[“Title”].Value;
}

if (link.ContainsKey(“linkText”))
{
linkText = link[“linkText”].Value;
}

if (link.ContainsKey(“internal”))
{
IComponent internalLink = link[“internal”].LinkedComponentValues[0];
href = internalLink.GetResolvedUrl();
}

if (link.ContainsKey(“external”) && !link.ContainsKey(“internal”))
{
href = link[“external”].Value;
}

if (link.ContainsKey(“type”))
{
string typeValue = link[“type”].Value.ToLower();
string size = “”;
if (typeValue.StartsWith(“modal”))
{
String[] values = typeValue.Split(‘_’);
if (values != null && values.Length >= 2)
{
size = values[1];
}
}
switch (typeValue.ToLower())
{
case “open new window”:
target = “_blank”;
break;

case “popup”:
target = “_customPopup”;
break;

case “modal”:
target = “_customDailog” + size;
break;
}
}

if (link.ContainsKey(“rel”))
{
string relAttribute = “”;
foreach (string relItem in link[“rel”].Values)
{
relAttribute += relItem.ToLower() + ” “;

}
relAttribute = relAttribute.Trim();
rel = relAttribute;
}
}

You may need to use the following objects using DD4T.Factories namespace.

private static IComponentFactory _componentFactory = null;
private static IComponentFactory ComponentFactory
{
get
{
if (_componentFactory == null)
{
_componentFactory = new DD4T.Factories.ComponentFactory();
}
return _componentFactory;
}
}
private static ILinkFactory _linkFactory = null;
private static ILinkFactory LinkFactory
{
get
{
if (_linkFactory == null)
_linkFactory = new DD4T.Factories.LinkFactory();
return _linkFactory;
}
}

These are some standard methods can be useful in most of the tridion projects but these are dependent on the customization logic you / business want to include. For any further helper method logic, reply to this blog, will try to help you !!

Happy Coding !!

 

Caching with Tridion, DD4T

Caching is a necessity for any web application for better performance. The same is applicable for any Tridion (.Net) based project as well.

You must be aware of the Tridion Caching Mechanism but this article is not relate to it.

Here, i will discuss the standard caching mechanism which can be used in any standard Tridion/DD4T (.Net) based project with very minimal modifications.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Runtime.Caching;

namespace Helpers.Caching.Utils
{
public class CacheClassGeneric
{
// default value to Cache expiration
const double CacheTime = 10;

/// <summary>/// Insert key into Cache and expire at specified time
/// </summary>
/// <param name=”key”> key identifier</param>
/// <param name=”value”>object to be stored</param>
/// <param name=”value”>total minutes for the cache to expire </param>
public static void StoreInCache(string key, object value, double totalMinutes = CacheTime)
{
HttpRuntime.Cache.Insert(key, value, null, DateTime.Now.AddMinutes(totalMinutes), System.Web.Caching.Cache.NoSlidingExpiration);
}

/// <summary>
/// Insert given key into Cache and expire at specified time
/// </summary>
/// <param name=”key”> key used to store in cache</param>
/// <param name=”value”>object that needs to be stored</param>
/// <param name=”value”>total minutes for cache to expire</param>
public static void StoreInCache(CacheKey key, object value, double totalMinutes = CacheTime)
{
HttpRuntime.Cache.Insert(key.ToString(), value, null, DateTime.Now.AddMinutes(totalMinutes), System.Web.Caching.Cache.NoSlidingExpiration);
}

/// <summary>
/// Inserts user information to cache which expires at specified time
/// <param name=”key”> key identifier</param>
/// <param name=”value”>object to be stored</param>
/// <param name=”value”>total minutes for cache to expire</param>
/// </summary>
public static void StoreInCacheLive(string key, object value)
{
if (HttpRuntime.Cache[key] == null)
{
HttpRuntime.Cache.Insert(key, value, null, System.Web.Caching.Cache.NoAbsoluteExpiration, System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, null);
}
else
{
HttpRuntime.Cache[key] = value;
}
}

/// <summary>
/// Load the Cached object by the key
/// </summary>
/// <param name=”key”> key used to retrieve the value in cache</param>
public static object GetFromCache(String key)
{
object cachedData = HttpRuntime.Cache[key];
if (cachedData != null)
{
return cachedData ;
}

return null;
}

/// <summary>
/// Load the Cached object by the key
/// </summary>
/// <param name=”key”> key used to retrieve the value in cache</param>
public static object GetFromCache(CacheKey key)
{
object cachedData = HttpRuntime.Cache[key.ToString()];
if (cachedData != null)
{
return cachedData ;
}
return null;
}

/// <summary>
/// Remove Key from cache
/// </summary>
/// <param name=”key”></param>
public static void RemoveFromCache(string key)
{
HttpRuntime.Cache.Remove(key);
}

/// <summary>
/// Remove Key from cache
/// </summary>
/// <param name=”key”></param>
public static void RemoveFromCache(CacheKey key)
{
HttpRuntime.Cache.Remove(key.ToString());
}

}
public enum CacheKey
{
//configure it for your case, as needed

PageUrls = 1,
Authenticated = 2,
Forms=3,
GenericItem = 4,
Forms = 5,
Capabilities = 6
}
}

This is the complete class file and code can be used as Master class file for Caching logic implementation in your project. For any further clarification please reply on this blog !!

Happy Coding !!

Getting Started with Tridion Event System !!

Tridion Event System?

An Event Handler is a .NET assembly that uses the Event-System to hook into events that are occurring in the Content Manager. An Event Handler is triggered when an event occurs, like when a Component being saved or Page is published. In Tridion, most of the CMS features are event driven.

Why Event System?

• Using Event System customization (business logic) can be performed on any particular event on the CMS itself. Below is an example:
  • OnComponentSavePre / OnComponentSavePost – Logic can be placed before / after saving any component (e.g. auto value population on fields, auto page & CP creation with the created component and publishing the same)
• Automation of any CMS process (events) can be done. (e.g. Auto Publishing of pages based on some business logic)
• Event system can be used with Tridion Workflow System for approval processes to be in place on event call.

Logic can be applied in any of the event phases as per the above pic:

Advantages of Event System

• Using Event System, business logic can be placed on Content Manager End to avoid redundancy / complexity in the delivery end (i.e. Presentation Server).
• If Business wants to perform any specific task (Custom logic automation) before publishing content from Tridion then event system will allow doing the same before pushing the content to database or file server.
• Event system can be extended as and when required, as per business need.
• Same can be extended in future to provide constructed solution to any such requirements rather than using any out of the box program.

Let’s see a practical scenario of using Event System along with workflow.

 

 

Code Sample with deployment steps:

You can perform a test run on event system deployment on the development server:

• Designing and developing sample POC to set up Event System using Tridion’s API and .NET.
• Configuration changes on CMS server to register the event system.
• Testing the event system.

Now it’s time to get started with coding!!

Basic but Important, you must use the “Tridion.ContentManager.Extensibility.TcmExtension” namespace to get all required items to get started.

Create a class and define TcmExtension attribute that includes a unique ID for your Event Handler. We can have multiple Event Systems (dlls installed) with different TcmExtension attributes.

Subscribe the Event (with item type and Arguments in place). In this case event phase is Initiated as the event I am using is OnComponentSavePre. For post it will be TransactionCommited.

You must place the Subscribe() method inside class constructor as only this is getting called when events are triggered.

Then the Subscribe method as below.

Write Custom Logic for your Event now as required. I have put a very simple logic just to get started.

Here, the title of Components which are based on Schema ‘EventSystem’ will be changed dynamically when the mentioned event will be fired.

Now, Build your project and you should see the following in Output window:

1>------ Build started: Project: EventSystemTest, Configuration: Debug Any CPU ------
 1> EventSystemTest -> C:\Tridion\Projects\EventSystem\EventSystemTest\bin\Debug\EventSystemTest.dll
 1> Running Code Analysis...
 1> Code Analysis Complete -- 0 error(s), 0 warning(s)
 ========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========

Once your dll is ready you need to install / register it on the CMS server itself.

Steps to Register Event System dll :

1. Copy the DLL on the CMS server
2. Register the event class by updating the C:\Tridion\Config\Tridion.ContentManager.config file

<extensions>
<add assemblyFileName=”C:\Program Files (x86)\Tridion\bin\ EventSystemTest.dll”/>
</extensions>

3. Restart the following on CMS server

• Tridion COM+
• Tridion Content Manager Service Host service
• Tridion Content Manager Publisher service

Now you are set to test your Event System. Go ahead in Tridion GUI and create one Component with the Schema (You can change the schema name as your wish) and then it should work. If any errors come up put some logging logic (Event Viewer) in the code and also you can debug in Visual Studio by attaching to Process (dllhost.exe / TcmPublisher.exe) to see the actual error.

Use this template and write your own custom logic to start your first Event System!!

Check more on Event System from here SDL Live Content (login required).

Happy Coding !!

Getting Started with Tridion Core Service : Part 2

Implementation Scenario : Part 2

In the previous post we have seen how to configure and create wrapper class for using the core service. Now, we will see some advance cases.

Creating Keyword in a given category (from delivery end updating CMS content)

First, create a SessionAwareCoreServiceClient object. Then your method for adding a keyword in a given category. The category id, pub id, and keyword information (wrapped in model) needs to be provided, which will be required anyway.

private static SessionAwareCoreServiceClient client;

Following class is for holding required values for keyword in a category.

Another Scenario, Getting list of Templates from any publication. First create the filter for getting templates only.

private static RepositoryItemsFilterData GetTemplateFilter()
{
RepositoryItemsFilterData templateFilter = new RepositoryItemsFilterData();
List<ItemType> types = new List<ItemType>();
types.Add(ItemType.Page);
templateFilter.Recursive = true;
templateFilter.BaseColumns = ListBaseColumns.Extended;
templateFilter.ItemTypes = types.ToArray();
return templateFilter;
}

Now, just apply the filter to retireve lst of items (XElement). Then loop through to get templates in the provided publication (pubid).

RepositoryItemsFilterData templateFilter = GetTemplateFilter();
XElement templates = client.GetListXml(“tcm:0-XX-1”, templateFilter);

Foreach, item in the XElement, retrireve the Component Temaplate (title, linked schema etc)

 ComponentTemplateData t = (ComponentTemplateData)client.Read(AttributeValueOrEmpty(template, “ID”), null);
// t.Title;

Hope this give you some ideas on Core Service uses and applicability !!

Check more information on Tridion Core Services from here SDL Live Content (login required).