Web Content Management

Introduction to Jahia's RSS Social Component Module

Wed, 16 May 2012 16:17:00 GMT

When it comes to developing your own web content application, website or professional web application, there are many CMS platforms (both licensed and Open Source) that you can choose from. However, I think that Jahia xCM is a great tool for this type of project.

What makes Jahia xCM a good choice? The awesome Java Technology Platform it uses as base technology and the list of features available for administrators, developers and editors are just some of the reasons. Comparing Jahia to other CMS platforms can get cumbersom, but I think one powerful feature in particular makes it stand out: its modular architecture.

Modules

On the Jahia website, there is documentation about what modules are and how to build and work with them: "Each module is equivalent to a “plug-in” which extends the functionality of Jahia and manages one or several specific business case."

It's that simple. A module is a piece of software you can build and deploy to accomplish with a specific requirement on your website or web application. This is really interesting, specially for architects and developers, because it represents the solution for most of the complex requirements on a project.

Display external RSS feed

Jahia xCM comes with a great list of modules that are comparable to other CMS platforms on the market. Those modules are classified under several categories (this is really well documented on provided link). Here I'll go through the features of a specific module found into the "Social Components" category: "Display external RSS feed".

As the name implies, this module is an RSS feed client that displays content from any public access source. As we can expect, there are some basic attributes to configure the behavior of this module:

RSS feed URL: the URL of the RSS feed source.
Number of entries per pages: This attribute controls how many feed items you want to display. This is not related to pagination.

Let's go with a sample to see the module working using the integration environment described here [link to previous post]):

First let's create a new project on Jahia xCM 6.6 using the system templates (I called it test-project). This will let us start from scratch without any template or CSS issue.
Add a page under the Home using the "simple" template (I called it rss_client).

The project should look like this on edit mode:

Make a module available for a project

All the modules deployed into the Jahia xCM host (deployed [link to a post about deploying modules]) can be used on all the projects hosted there, but since version 6.6 of Jahia xCM modules are not "available" by default for all projects. This means if you need a specific module (provided by Jahia xCM or deployed by you), you need to make it available for the project.

This can be done two ways:

On the project creation process, there is a new step where you can select the module or modules that you want to activate for the new project.
In case of existent projects you can make a module available using the Studio UI just deploying the specific module. This works the same as when you need to deploy a template set to a specific project after doing modifications.

In our case, we need to deploy the module Jahia RSS Feeds (1.2) on the test_project:

Using the module

Once the module is available for the test_project, we can add it into the specific area we want. For this sample we're going to use the "listA" content area (see nextimage) to add the module:

We need to define the values for the module:

As the result of this process, we should see the two first items of the RSS feed displayed into the page area:

Using the Jahia Admin Tool

Mon, 14 May 2012 16:09:00 GMT

Working on Jahia xCM projects as a developer requires good administrative knowledge of the CMS. If you have experience on different CMS systems then you know what I'm talking about. As a developer, there are some scenarios where you need to perform tasks like quickly removing project content, testing a new custom functionality over the project content structure, testing custom queries over the projects content, etc.

On Jahia xCM, developers and administrator have a powerful tool called "Jahia Admin Tool". This is a web application that is configured on the "installation procedure" (installation asks for a password for this tool) and is available under the Jahia web application context used on the installation. If your Jahia web application context is "/", the tool will be on "/tool" web context.

This application has a lot of interesting features, below is a screenshot of the application menu:

The menu of the main page is self descriptive in that the items are grouped under categories that guide administrators on the specific tasks available. For example, if the task you're looking for is about getting system information or maybe forcing the garbage collector process then you can go to "System and maintenance" category.

As we're focused on developers tasks we will start checking the "JCR Data and Rendering->JCR repository browser" option.

There are two tasks where I used the Admin Tool and got great results:

Navigate the JCR repository of a specific project
Quickly remove content from the JSR repositories (default and live)

The first one is really important if you're trying to list the properties of a specific content node on a project. When you are creating JCR queries (here a link to JCR queries post) most of the times you need to build queries over content nodes of the projects that inherits from Jahia xCM provided content nodes (eg: most of the content nodes inherits from jnt:content).

If the parent content nodes already defined a specific attribute, then your new content node doesn't defines the attribute again, so you need to know the available attributes your new content node has and then use the attributes on a query.

Here is where the JCR repository browser helps, looking into a content node definition without checking into source code. Let's see the information available for a content node I created. ont:testmodule1:

All the content nodes are listed under "/jcr:system/jcr:NodeTypes/" path, so if you know the content node you want to see, just add into this path and the browser will find and display all its content definition for you. The info includes the child nodes if there are any and the supertype so you can check the parent node's information browse into the node using the links.

The second task is more common: delete content.

If you understand how Jahia uses two JCR repositories "default" and "live", the publication of content, and you want to remove content from each one of the JCR repositories, then the Admin Tool will be very helpful for you. If you want you delete a single page from the project content (default or live) then the editor mode will be fine, but if you want to remove a lot of content or even all "live" repository content then the editor mode doesn't help much.

For this case you can go to the JCR browser and find the content of the specific project using this path: "/sites/$projectName" and the browser will show you the project existent content.

Two important things before continue:

You can switch between the default and live repository using the link on the upper area of the administration tool:
You need to activate the actions on the JCR browser, this option is on the upper right area:

So if the goal is to delete content from the "live" repository we can switch to live and select the delete option over the node or nodes we want to delete. This action will be applied recursively, so all child nodes will be deleted from the repository.

The show actions will display more options than delete content, you can use this to export (xml, zip format) or to rename a specific node.

I hope you will find a lot more of tasks where the admin tool becomes a plus.

EPiServer Property Configuration with PageTypeBuilder

Fri, 11 May 2012 15:51:00 GMT

In my previous post, I talked about how to assign properties (fields) to tabs in EPiServer using PageTypeBuilder. Property types such as Drop Down Lists or the XHTML Editor usually need some additional configurations (such as what values to display/restrict in the drop down menu). This is usually done in the EPiServer Admin mode graphical interface. But in version 1.0 of PageTypeBuilder, this couldn't be done; you had to go to the Admin mode interface to do individual configurations manually, one-by-one, defeating the purpose of synchronizing the Page Types between environments automatically.

Fortunately, PageTypeBuilder 2.0 introduced a mechanism to configure properties by implementing the PageTypeBuilder.IUpdatePropertySettings<T> interface. An Attribute class (i.e., that inherits from System.Attribute) must implement this interface. The "T" type in the generic IUpdatePropertySettings interface declaration must be an EPiServer property settings class, such as EPiServer.Web.PropertyControls.PropertySettings.MultipleOptionsListSettings or EPiServer.Editor.TinyMCE.TinyMCESettings.

The following example shows how to create a Drop Down List configuration class that defines the values that can be chosen from the list:

public class ScrollSettingsIFrameAttribute : Attribute, IUpdatePropertySettings<MultipleOptionsListSettings>
{
  public int GetSettingsHashCode(MultipleOptionsListSettings settings)
  {
    return (settings.ListOptions != null ? settings.ListOptions.Count : 0);
  }

  public bool OverWriteExistingSettings
  {
    get { return true; }
  }

  public void UpdateSettings(MultipleOptionsListSettings settings)
  {
    Dictionary<string, string> options = new Dictionary<string, string>();
            
    options.Add("no", "no");
    options.Add("yes", "yes");
    options.Add("auto", "auto");

    settings.ListOptions = options;
  }
}

Once defined, the attribute class can be used in the declaration of a property in a Page Type class:

public class PageWithIFrame : TypedPageData
{
  //... Other property declarations ...
  
  [PageTypeProperty(
    EditCaption = "iFrame scroll bars",
    Type = typeof(PropertyDropDownList),
    SortOrder = 50)]
  [ScrollSettingsIFrame]
  public virtual string Scrolling { get; set; }
}

The following example configures the TinyMCE editor for XHTML properties to display the "formatting" drop down list in the toolbar, uses the stylesheet declaration in the project's "/css/style.css" for the styles drop down menu, and defines the size of the editor:

public class HtmlEditorSettingsAttribute : Attribute, IUpdatePropertySettings<TinyMCESettings>
{
  public int GetSettingsHashCode(TinyMCESettings settings)
  {
    return settings.Height + settings.Width;
  }

  public bool OverWriteExistingSettings
  {
    get { return true; }
  }

  public void UpdateSettings(TinyMCESettings settings)
  {
    int totalToolbars = settings.ToolbarRows.Count;
    ToolbarRow row = settings.ToolbarRows[totalToolbars - 1];
    row.Buttons.Add("formatselect");

    settings.ContentCss = "/css/style.css";
    settings.Height = 400;
    settings.Width = 615;
  }
}

Once defined, use the attribute in the declaration of a XHTML property in a Page Type class:

public class SubPage : BasePageType
{
  // ... Other property declarations ...

  [PageTypeProperty(
    EditCaption = "Body HTML",
    Type = typeof(PropertyXhtmlString),
    SortOrder = 22)]
  [HtmlEditorSettings]
  public virtual string Body { get; set; }
}

You can find information about the TinyMCE configurations by searching the web, since TinyMCE is a standard JS-based editor not developed by EPiServer.

Sitecore Navigation Using Renderings

Mon, 07 May 2012 15:47:00 GMT

In a recent Sitecore project by Oshyn, I was given the task of creating main navigation and left categories navigation. I had to decide whether to build those navigations using either rendering or using a .NET user control.

The most common approach to building Sitecore navigation is rendering, because of its performance and easy-to-build and deploy code. A sublayout using a user .NET control is also a good alternative; it is becoming more common in recent Sitecore versions to see navigations implemented with sublayouts. The benefit to use a sublayout is the ability to use c# code to manipulate nodes and its properties.

The navigation menu I needed to develop was very straightforward and since I had the chance to start creating the nodes myself, I chose to build the main navigation and left navigation using rendering.

The structure of the site is similar to this graph:

Include in navigation (IncludeInNav),is channel page (IsChannelPage) and include in sitemap (IncludeInSitemap) are the properties that each page node will need to have. The first property tells if a page node is eligible for the top navigation. The second property tells if a page node is the channel page (a channel page is the main page in a category hierarchy), and the third option is used for creating a sitemap (I will talk about creating a sitemap in a future post).

On the rendering code, we need to set a home variable. This home variable represents the root node or home node. Starting from the home variable, the code will extract all child nodes that meet the IncludeInNav property and the IsChannelPage to true. Now that we have a set of nodes that are channel pages (categories), we proceed to iterate on every one and print the appropriate HTML for that node. For each category, we also execute a query to find the children of each category.

To do this on every iteration of the categories nodes, we query again down the subtree for nodes that meet the IncludeInNav parameter to true. For each of the retrieved set we print the appropriate HTML.

As you can see, creating the top navigation structure using rendering is a very straightforward approach. It loads very fast, which I was very please with.

Here are some important lines of code that you might find useful.

Selecting home node:

Iterating through categories nodes:

EPiServer Tab Assignment with PageTypeBuilder

Thu, 03 May 2012 16:35:00 GMT

In my previous post, I demonstrated how to implement a hierarchical inheritance structure for Page Types in EPiServer using PageTypeBuilder. But all the properties are created under the default “Content” tab in Edit Mode. One of EPiServer’s nicest features is the ability to organize properties into tabs; to avoid cluttering the editor’s interface, group related properties and assign user permissions to a group of properties.

PageTypeBuilder allows you to create tabs, and assign properties to them. Creating a tab, is as simple as creating a class that inherits from PageTypeBuilder.Tab:

public class Promotions : PageTypeBuilder.Tab
{
  public override string Name
  {
    get { return "Promotions"; }
  }

  public override AccessLevel RequiredAccess
  {
    get { return AccessLevel.Edit; }
  }

  public override int SortIndex
  {
    get { return 20; }
  }
}

The Name property is the text you want to display on the tab.
The RequiredAccess property allows you to assign user permissions to the tab by using EPiServer.Security.AccessLevel enum.
The SortIndex property allows you to position the tab in the Editor pane.

To assign properties in any Page Type to a tab, include the “Tab” parameter in the PageTypeProperty attribute declaration:

public class HomePage : BasePageType
{
  [PageTypeProperty(
    EditCaption = "Promotion Image",
    Type = typeof(PropertyImageUrl),
    Tab = typeof(Promotions),
    SortIndex = 40)]
  public virtual string PromoImage { get; set; }

  [PageTypeProperty(
    EditCaption = "Promotion Link",
    Type = typeof(PropertyPageReference),
    Tab = typeof(Promotions),
    SortIndex = 41)]
  public virtual PageReference PromoLink { get; set; }
}

When structuring your project, make sure to locate your Tab classes in a namespace that is “global” to all Page Type classes.

In an upcoming post, I’ll talk about how to configure special properties, such as TinyMCE options for XHTML fields.

Introduction to Jahia JCR Query Languages

Thu, 19 Apr 2012 15:26:00 GMT

When you come to Jahia xCM and start working on a website you will find that one of the core technologies behind the CMS is the Apache Jackrabbit project. This is the most mature implementation of the JCR specification available in the open source context market.

If you want to achieve good results with the functionalities implemented on your Jahia projects, then you will need to use the JCR API related features of the CMS. This will let you build custom navigation, content lists and solve complex requirements that demand advanced management of the project content.

What's JCR?

If you're unfamiliar with JCR, a good place to find our more is the Wikipedia page. Here you'll learn that JCR "is a specification for a Java platform application programming interface (API) to access content repositories in a uniform manner¹". On this page, along with other information available online, you will find definitions for this 'specification' like: content database, content relational database, and some people even associate a JCR implementation with a kind of graph database.

There is another definition available for JCR that is not covered in this post, but is still important in keeping with the Apache Jackrabbit definition: "A content repository is a hierarchical content store with support for structured and unstructured content, full text search, versioning, transactions, observation, and more."

Here, I'll focus on one part of this technical specification (JCR specification JCR-283) : queries. More specifically, queries supported in Jahia xCM.

Since Jahia xCM is built over the Apache Jackrabbit project, most of the features of this implementation API are available on Jahia. There is one exception about the support of XPATH as a valid query language used with the JCR repository: the technical specification deprecated its use but Jahia xCM still supports it.

Supported Query languages

Well lets start listing the supported query languages of the JCR specification and some key concepts.

Abstract Query Model: This is the core implementation of the logic that brings to the repository the "queries" as a feature. This means all the queries supported by the JCR implementation will be processed here no matter what query language is used.
JCR-SQL2: This query language lets the users (developers) write query sentences similar to SQL language to build the queries over the JCR repository content nodes.
JCR Java Query Object Model (JCR-JQOM): This is an API that lets developers to build the queries into Java code and exposes the results as objects trees. If you are familia with the JPA specification for persistence, this will be more like a Object Query Language.

To illustrate a little about each of the languages lets see how a general query is structured on each one:

JCR-SQL2

    
            'SELECT' columns
'FROM' Source
['WHERE' Constraint]
['ORDER BY' orderings]

JCR-JQOM

    
            QueryObjectModel obj = QueryObjectModelFactory.createQuery(
    Source source,
    Constraint constraint,
    Ordering[] orderings,
    Column[] columns);

        

Building Queries

As I mentioned before, JCR repositories are designed to store content. This content is stored into the repository as a "content node" which means the repository needs to know about each type of node it will store to be able to index nodes data. Once it indexes this data, it then query nodes using that data or performs any internal operation over the nodes information.

Then the concept and definition of "Node Type" become extremely important for the query editors as well as one of the most powerful features of the JCR repository. As a consequence, on Jahia xCM, this will be the base technology for a lot of conventional tasks when implementing functionalities for a website. A good documentation for this topic is available on the Apache Jackrabbit website, there you can learn about Node Type Definitions creation, inheritance, constraints, etc.

Let's start with a Node Type Definition for a specific type of content on a Jahia project: Page

    
            Name: jnt:page
Type: nt:nodeType
Properties:
    jcr:hasOrderableChildNodes:  true
    jcr:isMixin:  false
    jcr:nodeTypeName:  jnt:page
    jcr:mixinTypes: []
jcr:supertypes: 
    jmix:basemetadata
    jmix:hasTemplateNode
    jmix:navMenuItem
    jmix:nodenameInfo
    jmix:observable
    jmix:publication
    jmix:tagged
    mix:title
    nt:base

        

On the Node Type Definition for the Page we can see the list of properties and the list of super types this node inherits properties from. Then if we want to use this node on a query, we can write a sentence like:

select * from [jnt:page] as page order by page.[jcr:lastModified] desc

The result of this query will be a list of content nodes of type jntage and ordered by the jcr:lastmodified (Date) property value.

Note that on this sample query we had used a specific content node (jntage) and one inherited property of this content node (jcr:lastModified). You can try to build the entire inheritance tree for jntage to check all the node properties available for querying. Now you can think about the power of queries when you need to build custom lists of content on your project, like customized navigations for pages or lists of specific components.

One remarkable thing this sample shows to us is the importance of the knowledge about the content Node Type Definition (CND files on Jahia) of the Jahia Core API and the specific project content created for the developers.

I believe this is the most important and useful feature of the entire Jahia xCM.

On a future post I want to go deeper on more elaborated queries (JCR-SQL2 and JCR-JQOM) and the Jahia Admin Tool. A very useful feature of this web application is a JCR browser where you can test your JCR queries.

References:

¹ www.wikipedia.org

Installation Tips for a Jahia Setup on Linux OS

Thu, 26 Apr 2012 16:06:00 GMT

Jahia is an open source web content integration software that combines enterprise web content management with document management and portal features¹. The Jahia setup on a Linux (Debian GNU/Linux) server is simple.

To start, read the Jahia xCM community documentation as a first step to start testing your own CMS instance as a developer. The documentation has important tips and recommendations for developers and administrators to ensure the setup of your CMS instance will be quick and easy.

For Jahia beginners,the community documentation and the Wiki (Jahiapedia) content available on the Jahia website will be really helpful. Your first project creation, the introduction to basic concepts of the CMS, and the templates creation guidance will help you quickly start your first web content project with this CMS.

The scope of this post is to show you the setup of the Jahia xCM on a Linux host using the command line mode of the installer. I’ll also go over how to check the basic configuration parameters and files that should be in place to start working with Jahia xCM V6.6.0.0.

To start with the installation, we need to check the following system requirements:

JDK (Java development kit) and Tomcat6 (Apache Servlet Container)

The Jahia xCM is a web application built over the Java Servlet Specification 2.4. This means it could be deployed on a JDK 1.5 and a servlet container that implements this specification like Tomcat 5.5.X; however, following project recommendations we will use JDK 6 and Tomcat6 for this setup.

Install Java Development Kit v6 using the apt package manager:

apt-get install openjdk-6-jdk

The apt will set all environment variables (JAVA_HOME, PATH) and the Java commands will be available and detectable by the Java applications on this host. On the terminal, you can check the installation by typing in "java -version" and you should see this command:

java -version

java version "1.6.0_18"

OpenJDK Runtime Environment (IcedTea6 1.8.10) (6b18-1.8.10-0+squeeze2)

OpenJDK 64-Bit Server VM (build 14.0-b16, mixed mode)

Now we can install the Tomcat6 servlet container using the apt tool:

apt-get install tomcat6

Again, the apt will take care of the entire setup and default installation (environment variables and system V init scripts) for the servlet container as an OS service.

That's all, Now our Linux OS is ready for deployment.

Jahia xCM Installation

The Jahia community installer is available for Linux/OSX on the community downloads page as well as install instructions for the Java graphical installer. To get the installer, use wget/curl tools to get the distributed jar file:

wget --no-check-certificate https://www.jahia.com/public/jahia-6.6.0/bin/Jahia_xCM_v6.6.0.0_r40429.jar

To start the installer on the terminal type, use:

java -jar Jahia_xCM_v6.6.0.0_r40429.jar

This will start the installer on command line and you will see all the steps described on the graphical installer. On command line format, then you can follow the same steps. The difference here is that we want to deploy Jahia as a web application on our previously installed Tomcat6 and avoid using the bundled Tomcat that comes with the default installation.

To proceed with the command line installation, follow these steps:

Welcome to the installation of Jahia xCM 6.6.0.0!

- Jahia Solutions Group SA <info@jahia.com>

The homepage is at: http://www.jahia.com

[license information]

Select target path => usr/local/Jahia_xCM_v6.6.0.0

Here you can choose your preferred installation type => Custom install (advanced)

Select the installation type you want to perform: => Deselect Add Apache Tomcat

Choose your preferred database connection type => Use a standalone DBMS

Choose your DBMS type => MySQL 5.x

Database driver => com.mysql.jdbc.Driver

Database URL => jdbc:mysql://localhost/jahia?useUnicode=true&characterEncoding=UTF-8&useServerPrepStmts=false

Database username => jahia

Database password => jahia

Store binary data in the database? => No

Create required database tables? => Yes

Context name (context path without /) => jahia

Jahia tool manager username => jahia

Jahia tool manager password => jahia

Use development mode for templates? => Yes

Username: => root

Password: => jahia

Externalize configuration => No

[ Processing package: Jahia xCM + Jahia Composite Content Platform (1/1) ]

[ Unpacking finished ]

Install was successful

application installed on /usr/local/Jahia_xCM_v6.6.0.0

[ Console installation done ]

After the installation procedure is complete you can check the WAR file we need on the installation dir (/usr/local/Jahia_xCM_v6.6.0.0) named "jahia.war". This file is now a standard Java web application and we can proceed with the configuration for deployment on our Tomcat6 servlet container.

I followed the recommendation to use a web application directory outside the default Tomcat6 directories structure. This helps a lot on maintenance operations and simplifies Tomcat upgrades and/or Jahia upgrades. To do this, I'll unzip the jahia.war file in the "jahia_war" directory in the installation directory:

jahia_war

|---admin

|---css

|---engines

|---errors

|---favicon.ico

|---gwt

|---html

|---icons

|---iphone

|---jahia.war

|---javascript

|---LICENSE

|---META-INF

|---modules

|---ping.jsp

|---tools

|---WEB-INF

This is the web application content and in this structure, we can do all the modifications for the Jahia xCM setup we need. Now we need a deployment file for the Jahia web application.

During the installation process, we selected a web context different than "/" for the Jahia web application: "/jahia". This means that for our deployment, the file will be named "jahia.xml" and will be located into the $TOMCAT_HOME/var/lib/tomcat6/conf/Catalina/localhost/ directory. By default, this is the location of the deployment descriptors in Tomcat.

The content in this file should be:

<Resource

name="jdbc/jahia"

auth="Container"

factory="org.apache.commons.dbcp.BasicDataSourceFactory"

type="javax.sql.DataSource"

username="jahia"

password="jahia"

driverClassName="com.mysql.jdbc.Driver"

url="jdbc:mysql://localhost/jahia_6_6_0_0?useUnicode=true&characterEncoding=UTF-8&useServerPrepStmts=false"

defaultAutoCommit="true"

accessToUnderlyingConnectionAllowed="true"

maxActive="200"

maxIdle="30"

maxWait="10000"

initialSize="5"

validationQuery="/* ping */"

testWhileIdle="true"

testOnBorrow="false"

testOnReturn="false"

timeBetweenEvictionRunsMillis="300000"

minEvictableIdleTimeMillis="1800000"

numTestsPerEvictionRun="5" />

</Context>

This file can be created using the jahia_war/META-INF/context.xml file and modifying the "Context" tag.

Once you put this file into the Tomcat-specified location, you can restart the Tomcat service and the Jahia web application will start:

service tomcat6 restart

Now you can check your Tomcat6 LOG (/var/log/tomcat6/catalina.out) and see all the Jahia web application startup information. This file becomes especially important to a developer’s work as this contains all the deployment and execution information.

Now we can point our browser to http://localhost:8080/jahia and we should see the start configuration page.

About the Installer

The Jahia xCM 6.6 has been recently released, and I tried some installations before writing this post. On those tests I noticed some fails on the installer (in graphic mode). If this happens to you, I suggest you check the following on your recently installed environment:

The file $JAHIA_WAR/WEB-INF/etc/jahia.properties was sometimes missing.
The file $JAHIA_WAR/WEB-INF/etc/log4j.xml defines the location of the Jahia LOG files (jahia.log, jahia_profiler.log, jahia_access.log), search the file definitions into the "appender" tags and add the location you want for those files, in my case I want all log file under "/var/log/tomcat6/" directory:

<param name="File" value="/var/log/tomcat6/jahia.log"/>...

On the $JAHIA_WAR/WEB-INF/etc/jahia.properties there used to be the DB configuration parameters, but on this release you will find this comment:

######################################################################
### Database ########################################################
######################################################################
# Database connection configuration is no longer configured here,
# but rather through container-managed datasource connection. In Tomcat
# these can be found in the following file:
# <jahia-web-app-dir>/META-INF/context.xml

I tried moving all the DB configuration parameters to this file from the "jahia.xml" but had no luck, so it seems you need to use the jahia.xml to define DB attributes.

If all goes well, this host will work fine as an integration environment and by following the documentation about the performance tuning provided on Jahia website, this can be used as a start point for a production instance.

Resources

¹ www.jahia.com

What to Expect When Implementing a New CMS

Mon, 23 Apr 2012 21:16:00 GMT

When implementing a new CMS, it’s easy to get caught up in all the bells and whistles of the platform without considering the basic implications of a new system. What type of development method will you use? Who will own the project? How will you get everyone on the team on board? How to plan for the unexpected costs? How will you make sure everyone has the training and support they need.

Before you dive into a new CMS, it’s important to answer these questions to avoid wasting time and resources down the road.

Different Development Methodologies

There are three main types of CMS development methodologies, which one will be best for your project?

Waterfall – sequential development approach through Analysis, Design, Implementation, Quality Assurance, Integration, and Maintenance.
Incremental – breaks a project into smaller segments, reducing risk by working on smaller segments; also allows for some development flexibility.
Agile – iterative and incremental development where requirements and solutions evolve through collaboration between self-organizing/cross-functional teams.

The Need for a Product Manager/Owner

According to Forrester Research, more than 60% of Web Managers are dissatisfied with their current CMS. A lot of that dissatisfaction can be attributed to a CMS implementation that doesn’t address original business needs.

Having a Product Manager/Owner, someone that understands your needs and is responsible for the overall direction of your CMS, ensures that your CMS implementation stays on course and is not derailed by short term interests and conflicting visions.

Avoiding Adoption Issues

Humans are creatures of habit, so don’t expect your editors to fall in love with your new CMS just because it’s new and full of great features. Your CMS implementation will fail if you can’t get everyone pulling in the same direction.

How to encourage user adoption:

Clearly outline your goals and objectives
Involve your site users and editors during the Design Phase
Show your editors how your new CMS will make their day-to-day tasks easier
Offer support and training – this is paramount, but often overlooked

Different Users = Different Training Needs

Don’t assume that everyone on your team will find your new CMS easy to use. What is simple and intuitive to one person might not be to the next, so conduct training needs assessments and tailor your training accordingly. Try not to cut corners around training; it will cost you in the long run. For example, editors not following best practices and administrators not following security guidelines will cause major issues within your organization.

Unexpected Costs

Irrespective of which development methodology you use, some enhancements will only become apparent and necessary after you had a chance to test and use your new CMS. Create a plan and set aside additional funding to deal with future enhancements and to avoid launch delays caused by time or budgetary constraints.

You will Need Support

When something goes wrong, it can be very frustrating if no one can help you in a timely manner, particularly when the issue is out of your control and you are dependent on external support. Some open source and low-cost CMS offerings do not include support, so take time to evaluate your support needs before choosing a CMS.

Sources:
Software Development Methodology (Wikipedia)
Agile Software Development (Wikipedia)
Why Could Your CMS Implementation Fail? (SlideShare)

Creating a Simple EPiServer Page Type Hierarchy Using PageTypeBuilder

Fri, 27 Apr 2012 22:46:00 GMT

In my previous post, I did a short introduction to Joel Abrahamsson’s PageTypeBuilder library for EPiServer. Among other features, I did a quick description of one of PageTypeBuilder’s greatest features, structural inheritance. In this post, I’ll describe a simple hierarchical Page Type inheritance structure example.

Let’s begin with the “Base Page Type” (that inherits from PageTypeBuilder.TypedPageData):

public class BasePageType : TypedPageData
{
  [PageTypeProperty(
    EditCaption = "Page teaser",
    Type = typeof(PropertyString),
    SortOrder = 10)]
  public virtual string PageTeaser { get; set; }

  [PageTypeProperty(
    EditCaption = "Show top image",
    Type = typeof(PropertyBoolean),
    DefaultValue = false,
    DefaultValueType = DefaultValueType.Value,
    SortOrder = 11)]
  public virtual bool ShowTopImage { get; set; }
}

Each field is decorated with the PageTypeProperty attribute, where you can define its properties including the caption for the end user. After defining the base, we can implement “concrete” Page Type classes that inherit from the base, and implement their own specific fields:

[PageType(
  Name = "Site inner page",
  Description = "Page type for all inner pages.",
  Filename = "~/Templates/InnerPage.aspx"
  AvailablePageTypes = new Type[] 
    { 
      typeof(InnerPage), typeof(SubPage) 
    }
  )]
public class InnerPage : BasePageType
{
  [PageTypeProperty(
    EditCaption = "Page HTML Body",
    Type = typeof(PropertyXhtmlString),
    SortOrder = 20)]
  public virtual string Body { get; set; }

  [PageTypeProperty(
    EditCaption = "Promotional Image",
    Type = typeof(PropertyImageUrl),
    SortOrder = 21)]
  public virtual string PromoImage { get; set; }
}

The PageType attribute defines the name of the Page Type in EPiServer, a description of the page, and most importantly, the ASPX file name for the presentation of the Page Type (template). Also, you can specify an array of the Page Types that are allowed to be created (as page instances) under a page that has been instantiated from the Page Type being defined (i.e., when you create a page using the defined Page Type, its children are restricted to be of the types you entered in the array).

In the previous example, since InnerPage inherits from BasePageType, it will not only have the Body and PromoImage properties, but also the PageTeaser and ShowTopImage properties as well.

Finally, you can also implement subclasses of the “concrete” Page Type classes for specific functionality:

[PageType(
  Name = "Site subpage",
  Description = "Page type for third-level pages.",
  Filename = "~/Templates/SubPage.aspx")]
public class SubPage : InnerPage
{
  [PageTypeProperty(
    EditCaption = "Promotion link",
    Type = typeof(PropertyUrl),
    SortOrder = 30)]
  public virtual string PromoLink { get; set; }

  [PageTypeProperty(
    EditCaption = "Automatically redirect to",
    Type = typeof(PropertyPageReference),
    SortOrder = 31)]
  public virtual PageReference AutomaticRedirect { get; set; }
}

In this last example, the SubPage page type will inherit all the properties from its parents: PageTeaser, ShowTopImage, Body, PromoImage; and it will include its own properties PromoLink and AutomaticRedirect.

To create the actual templates (ASPX with the presentation of the Page Types), instead of inheriting from EPiServer’s standard TemplatePage, you have to inherit from PageTypeBuilder’s generic TemplatePage<T>, where T is the Page Type class that is associated to this presentation component:

public partial class InnerPage : TemplatePage<PageTypes.InnerPage>

You can access the Page Type’s fields in code-behind with the CurrentPage property normally by using string indexes, or better, by accessing them as standard .NET properties:

this.CurrentPage["Body"]
this.CurrentPage.PromoImage

In the ASPX front-end, you can still use the EPiServer:Property web control.

<EPiServer:Property PropertyName="Body" runat="server" />

In an upcoming post, I’ll describe how to assign Tabs to properties, and how to configure the TinyMCE editor for XHTML fields.

PageTypeBuilder for EPiServer

Fri, 27 Apr 2012 22:46:00 GMT

PageTypeBuilder, an open source project developed by Joel Abrahamsson is a great tool that helps managing, directly in code, Page Type definitions in EPiServer projects.

As anyone that has worked with EPiServer knows, Page Types are usually managed in the Admin interface, and they do not support advanced features like inheritance. You can use Dynamic Properties to somehow manage content that is shared among different page types in the project, but there isn’t real structural inheritance. Also, to synchronize Page Types between environments (such as when you have your project in a Continuous Integration deployment schema, with environments for Build, QA, Staging, Production, etc.), you have to manually export and import the Page Types in each one, or even worse, copy the entire database from server to server.

PageTypeBuilder easily solves this synchronization issue. All Page Types are defined in code, as any other class in C#. This means that, when you deploy the project to another environment, the Page Types will be automatically synchronized without further intervention. And since they are defined as C# classes, Page Type structure inheritance is as simple as inheriting one Page Type class from another Page Type class. You can even define “Base Page Types” that contain shared data fields; however they aren’t created in the system as actual Page Types. The “concrete” Page Type classes inherit from this Base Page Type class, and implement their own additional fields.

PageTypeBuilder also allows managing Tabs and, since version 2.0, Field Configurations. In upcoming posts, I’ll discuss these features in more detail.

PageTypeBuilder has its disadvantages and limitations. There are not many resources about it in the Internet, but you can always check Joel’s blog for introductions and examples. Also, since it creates the Page Type structures in the project’s database when first accessed, it doesn’t delete fields or Page Types that have been removed from the code. You will have to delete them manually in Admin mode.

In an upcoming blog post, I’ll give a simple example of how to create a simple Page Type hierarchy demonstrating inheritance and property configuration.

How to Easily Create a Page in Sitecore [Video Guide]

Fri, 06 Apr 2012 18:22:00 GMT

Sitecore is a Content Management system that allows you to easily create content for your site. You can create content pages with different layouts and various components depending on your site needs.

Creating a page in Sitecore is a simple and fast process after you figure out the two main components: page location and template.

Where will your page be located?

Before you create your page, you will need to know the basic structure, the main areas, and subpages of your site. After you know these, select the best location for the page.

What template is your page going to have?

The template of a page tells you how the elements of the page are distributed. In Sitecore, depending on your site, you can choose among several templates, like this one:

Or a template with 2 or 3 columns, like this one:

In Sitecore, each subsection of the page is considered a placeholder; be sure that you also know the names of the placeholders in the template you choose.

After you have decided on the location and the template of your page, watch the video, which will show you how to create a page in Sitecore and add content to it, including text and images. Additionally you can see how to submit pages if workflow is activated.

Finally once the page is created, the video will also show you, how to add a component to the left column of the page.

The video showed that Sitecore interface is easy to understand and navigate; editors can create new pages where they desire following few simple steps. Finally, editors can add components as needed; this helps you to have a site with up-to-date and personalized content for end users.

References

Sitecore CMS Brochure: http://www.sitecore.net/Resources/brochures/Sitecore-CMS.aspx

Sitecore Digital Marketing System (DMS) Part 2: Creating Conditions to compare custom values

Wed, 22 Feb 2012 23:52:00 GMT

In part one of this post, I showed you how to create new conditions for your Sitecore Digital Marketing System site. Now that we know the process,I’ll add some sample code to create conditions that will compare integer, dates and custom values.

Integer Condition (Number of Achievements):

using Sitecore.Rules;

using Sitecore.Rules.Conditions;

namespace RulesEngine.Rules

{

public class AchievementsCondition<T> :

IntegerComparisonCondition<T> where T : RuleContext

{

//This is the value the editor will enter

//I prefer to have a separate string property otherwise I could

//use base.Value int property but there will be errors if

//the editor doesn't enter a number

public string Number { get; set; }

/// <summary>

/// This function will be called to test the condition

/// </summary>

protected override bool Execute(T ruleContext)

{

//Get the current user from our dummy user session manager

var user = UserSession.GetCurrentUser();

//Check if the user is logged in, otherwise return false

if (user == null)

return false;

int numberToCompare;

if (!Int32.TryParse(Number, out numberToCompare))

{

//Return false if the editor didn't enter an integer.

return false;

}

//Assign the value to base.Value to perform the comparison

Value = numberToCompare;

//Use base function to compare the values, this will compare

//base.Value with the parameter sent

return this.Compare(user.NumberAchievements);

}

For our condition’s text we will use the macro “Operator” instead of the StringOperator we used for the nationality condition because this one will allow us to compare numbers and not strings:

where the user's number of achievements [operatorid,Operator,,compares to] [Number,Text,,number]

Date Condition (Registration Date):

using Sitecore.Rules;

using Sitecore.Rules.Conditions;

namespace RulesEngine.Rules

{

public class RegistrationDateCondition<T> :

OperatorCondition<T> where T : RuleContext

{

//This is the value the editor will enter

public string StartDate { get; set; }

/// <summary>

/// This function will be called to test the condition

/// </summary>

protected override bool Execute(T ruleContext)

{

//Get the current user from our dummy user session manager

var user = UserSession.GetCurrentUser();

//Check if the user is logged in, otherwise return false

if (user == null)

return false;

//Check the editor entered a value

if (string.IsNullOrEmpty(StartDate))

{

return false;

}

DateTime userRegistrationDate = user.RegistrationDate;

DateTime startDate =

Sitecore.DateUtil.IsoDateToDateTime(StartDate);

//Do a date comparison and take the result return a value

var compareResult =

userRegistrationDate.Date.CompareTo(startDate.Date);

//Get the operator the editor selected

switch (this.GetOperator())

{

case ConditionOperator.Equal:

return compareResult == 0;

case ConditionOperator.GreaterThanOrEqual:

return compareResult == 0 || compareResult > 0;

case ConditionOperator.GreaterThan:

return compareResult > 0;

case ConditionOperator.LessThanOrEqual:

return compareResult == 0 || compareResult < 0;

case ConditionOperator.LessThan:

return compareResult < 0;

case ConditionOperator.NotEqual:

return compareResult != 0;

default:

return false;

}

For the condition text, we will use the macro “DateTime” because we need to select a date. Sitecore already has that functionality built in:

where user's registration date [operatorid,Operator,,compares to] [StartDate,DateTime,,date]

Custom Values Condition (Marital Status):

using Sitecore.Data.Items;

using Sitecore.Rules;

using Sitecore.Rules.Conditions;

namespace RulesEngine.Rules

{

public class MaritalStatusCondition<T> :

WhenCondition<T> where T : RuleContext

{

//This is the value the editor will pick

public string MaritalStatusId { get; set; }

/// <summary>

/// This function will be called to test the condition

/// </summary>

protected override bool Execute(T ruleContext)

{

//Get the current user from our dummy user session manager

var user = UserSession.GetCurrentUser();

//Check if the user is logged in, otherwise return false

if (user == null)

return false;

if (string.IsNullOrEmpty(MaritalStatusId))

return false;

//Read the item selected

Item maritalStatusItem =

Sitecore.Context.Database.GetItem(MaritalStatusId);

if (maritalStatusItem != null)

{

//To make this sample as simple as possible, I'm only going to

//use the the item's name

//Use base function to compare the values

return user.MaritalStatus

.ToString()

.Equals(maritalStatusItem.Name,

StringComparison.InvariantCultureIgnoreCase);

}

return false;

}

For the condition text, we will use “Tree” and send a parameter with the location of the list of items that the editor will pick from:

where the user matital status is [MaritalStatusId,Tree, root=/sitecore/content/Configuration/MaritalStatus, specific marital status]

Now we are able to select as many conditions as we need.

For more information about personalizing content for your site visitor, refer to the Rules Engine Cookbook.

Post created by Juan Arias, Oshyn Inc. employee.

Sitecore Digital Marketing System (DMS) Part 1: Creating personalized, custom content for site visitors

Wed, 22 Feb 2012 23:05:00 GMT

Sitecore’s Digital Marketing System (DMS) can help you personalize the content your site displays to your users/visitors and can be easily customized to fit your specific requirements while using all the functionality that Sitecore already offers.

Let’s suppose you want to show different content modules to your users depending on their profile attributes like age, gender, number of twitter followers, number of achievements earned in the site, visitors without an account, etc.

We will need to let the site editor choose and create new rules that may include one or more profile attributes; therefore we can’t create a set of fixed rules to be used. Also, it is important to note that as result of our personalization, we will be required to:

Show a different sublayout
Hide the sublayout
Change the datasource of the sublayout

First, here is my User Profile class:

namespace RulesEngine.Session

{

public class UserProfile

{

public int UserId { get; set; }

public DateTime RegistrationDate { get; set; }

public string Nationality { get; set; }

public UserMaritalStatus MaritalStatus { get; set; }

public int NumberAchievements { get; set; }

}

public enum UserMaritalStatus

{

Single,

Married,

Divorced

}

To keep this demo as simple as possible, I’ll also create a dummy user session manager using a query string value to simulate the current logged in user:

namespace RulesEngine.Session

{

public static class UserSession

{

public static UserProfile GetCurrentUser()

{

var userId = HttpContext.Current.Request.QueryString["UserId"];

if (string.IsNullOrEmpty(userId))

{

//User not authenticated

return null;

}

UserProfile user = null;

switch (userId)

{

case "1":

user = new UserProfile()

{

UserId = 1,

RegistrationDate = new DateTime(2009, 10, 6),

MaritalStatus = UserMaritalStatus.Married,

NumberAchievements = 10,

Nationality = "British"

};

break;

case "2":

user = new UserProfile()

{

UserId = 2,

RegistrationDate = new DateTime(2005, 1, 26),

MaritalStatus = UserMaritalStatus.Single,

NumberAchievements = 55,

Nationality = "American"

};

break;

case "3":

user = new UserProfile()

{

UserId = 3,

RegistrationDate = new DateTime(2011, 2, 14),

MaritalStatus = UserMaritalStatus.Divorced,

NumberAchievements = 3,

Nationality = "French"

};

break;

case "4":

user = new UserProfile()

{

UserId = 4,

RegistrationDate = new DateTime(1999, 8, 30),

MaritalStatus = UserMaritalStatus.Single,

NumberAchievements = 8,

Nationality = "Ecuadorian"

};

break;

}

return user;

}

Let’s start with the user’s nationality. All we need to do is create a new class with StringOperatorCondition as the base:

using Sitecore.Rules;

using Sitecore.Rules.Conditions;

namespace RulesEngine.Rules

{

public class NationalityCondition<T> :

StringOperatorCondition<T> where T : RuleContext

{

//This is the value the editor will enter

public string Nationality { get; set; }

/// <summary>

/// This function will be called to test the condition

/// </summary>

protected override bool Execute(T ruleContext)

{

//Get the current user from our dummy user session manager

var user = UserSession.GetCurrentUser();

//Check if the user is logged in, otherwise return false

if (user == null)

return false;

//Use base function to compare the values

return this.Compare(user.Nationality, Nationality);

}

After a build of the solution, we need to register this new condition in Sitecore and copy the output dll file to the website’s bin directory (if using a separate project). Open Sitecore’s content editor and navigate to the location: /sitecore/system/Settings/Rules/Conditional Renderings/Conditions and create a new folder:

Then we create a new condition:

The Text field is the content that will be shown to the editor when selecting this condition, we put the following text:

where the user's nationality [operatorid,StringOperator,,compares to] [Nationality,Text,,nationality name]

Notice that it has some special content surrounded by square brackets. This tag has four parameters: the first is the name of the a property in the condition, the second parameter is the name of the sitecore's item also known as macro (located in /Sitecore/System/Settings/Rules/Common/Macros), the third parameter is a parameter that will be sent to the macro item selected in the second parameter, and the fourth parameter is the text shown to the editor before he enters a value for the condition. In our case we have:

Parameter	Object
operatorid	Sitecore.Rules.Conditions.StringOperatorCondition.OperatorId
StringOperator	/sitecore/system/Settings/Rules/Common/String Operators
(empty)	We don’t need a parameter
compares to	This text will be shown to the editor

Parameter	Object
Nationality	Our RulesEngine.Rules.NationalityCondition.Nationality
Text	It will request a single line of text
(empty)	We don’t need a parameter
nationality name	This text will be shown to the editor

To apply this new rule to our site, we go to the item we want to personalize, then go to Presentation -> Layout Details:

Then on the new window, click on Edit:

Under Controls, select the sublayout and click on Personalize. Notice that this Personalize button only appears once you add DMS to your Sitecore installation:

Then click on New Condition:

Enter a name for the condition and then click Edit:

Now we can select our new condition:

See part two of this post for how to create conditions that will compare integer, dates and other custom values.

Post created by Juan Arias, Oshyn Inc. employee.

Using WinSCP for SFTP connections from NAnt for Sitecore and EPiServer projects

Mon, 13 Feb 2012 19:23:00 GMT

Oshyn uses a combination of Jenkins and NAnt to do builds and deployments of our .NET projects (Sitecore and EPiServer). While this has worked great for us, one of the challenges has been the FTP deployments. We had been using the FTPTask from Spin The Moose which was previously found here: http://www.spinthemoose.com/~ftptask/.

The NAnt tasks looked like this:

<loadtasks assembly="${path::combine(nant-ftptask.dir, 'bin/Release/ftptask.dll')}" />
    <connection id="ftp-conn" server="${server.ftp}" username="${user.ftp}" password="${password.ftp}" />
    <connection id="ftp-conn-cd" server="${cd.server.ftp}" username="${cd.user.ftp}" password="${cd.password.ftp}" />
    <ftp connection="ftp-conn" remotedir="${remotedir.ftp}">
      <put type="ascii" localdir="${website-source.ftp}" remotedir="">
        <include name="Web.config" />
        <include name="Global.asax" />
        <include name="ClientEventTracker.ashx" />
        <include name="ClientEventTracker.js" />
        <include name="LuceneSearch.css" />
      </put>
      <!-- Include in the following PUT all DLLs that are not part of the standard Sitecore installation -->
      <put type="bin" localdir="${website-source.ftp}/bin" remotedir="bin" createdirs="true">
        <include name="*.dll" />
        <include name="*.xml" />
      </put>
      <put type="ascii" localdir="${website-source.ftp}/layouts" remotedir="layouts" createdirs="true">
        <include name="**.ascx" />
      </put>
      <put type="ascii" localdir="${website-source.ftp}/xsl" remotedir="xsl" createdirs="true">
        <include name="**" />
      </put>
      <put type="ascii" localdir="${website-source.ftp}/js" remotedir="js" createdirs="true">
        <include name="**" />
      </put>
      <put type="bin" localdir="${website-source.ftp}/img" remotedir="img" createdirs="true">
        <include name="**" />
      </put>
      <put type="ascii" localdir="${website-source.ftp}/SearchUtils" remotedir="SearchUtils" createdirs="true">
        <include name="*.aspx" />
      </put>
      <put type="ascii" localdir="${website-source.ftp}/WebServices" remotedir="WebServices" createdirs="true">
        <include name="*.aspx" />
      </put>
      <put type="ascii" localdir="${website-source.ftp}/css" remotedir="css" createdirs="true">
        <include name="**" />
      </put>
      <put type="ascii" localdir="${website-source.ftp}/App_Config/Include" remotedir="App_Config/Include" createdirs="true">
        <include name="Sitecore.Analytics.ExcludeRobots.config" />
        <include name="Sitecore.Analytics.config" />
        <include name="ldap.config" />
      </put>
      <put type="ascii" localdir="${website-source.ftp}/App_Config/Security" remotedir="App_Config/Security" createdirs="true">
        <include name="*" />
      </put>
      <put type="ascii" localdir="${website-source.ftp}/App_Config" remotedir="App_Config" createdirs="true">
        <include name="*.config" />
      </put>
      <put type="ascii" localdir="${env-config-source.ftp}" remotedir="App_Config/Include" createdirs="true">
        <include name="Sitecore.Analytics.config" />
        <include name="ScalabilitySettings.config" />
        <include name="Forms.config" />
      </put>
      <put type="ascii" localdir="${env-config-source.ftp}" remotedir="App_Config"  createdirs="true" unless="${string::contains(environment.param, 'Prod')}">
        <include name="*.config" />
      </put>
      <put type="ascii" localdir="${env-config-source.ftp}/CM" remotedir="App_Config"  createdirs="true" if="${string::contains(environment.param, 'Prod')}">
        <include name="*.config" />
      </put>
    </ftp>
    <!-- The following FTP transfer is used only for Content Delivery server -->
    <ftp connection="ftp-conn-cd" if="${string::contains(environment.param, 'Prod')}">
      <put type="ascii" localdir="${env-config-source.ftp}/CD" remotedir="/Include">
        <include name="SwitchMasterToWeb.config" />
      </put>
      <put type="ascii" localdir="${env-config-source.ftp}/CD" remotedir="/">
        <include name="ConnectionStrings.config" />
      </put>
    </ftp>

However, as you can see if you followed the link, Dave Alpert has apparently stopped supporting the task.

We've been using this task for FTP protocol, but it does not support SFTP. We quickly found there was no NAnt task alternative that did SFTP (at least not in a few hours of googling) so we decided to shell out using the <exec/> command. The options for this were psftp.exe and WinSCP. PSFTP appeared to be the easier and smaller footprint option so we tried that first. The issue we encountered was how to get the program to not prompt the user to accept the key. If Jenkins is running as SYSTEM service, it is not possible to get it to accept the key automatically. After various attempts with wrapper shell files to redirect "Y" to stdin and registry settings, PSFTP was eventually abandoned.

WinSCP, it turns out, has a way to send in the key fingerprint via the command line. This proved to work successfully and in fact, makes our NAnt a lot cleaner. There are two steps involved:

Creating the FTP Command file
Executing the FTP Command file

Creating the FTP Command File

The FTP Command file contains as the first line the connection string including the -hostkey parameter as follows:

    <property name="connectionString.ftp" value="open sftp://${user.ftp}:${password.ftp}@${server.ftp} -hostkey=&quot;${rsakey.ftp}&quot;"/>
    <echo file="${ftp.command.file}">
      ${connectionString.ftp}
      option echo off
      option batch on
      option confirm off
      option exclude "*/.svn; *.cs; *.example; *.pdb;"
    </echo>
    <echo file="${ftp.command.file}" append="true">
      cd ${remotedir.ftp}
      ascii
      put "${website-source.ftp}\*.config"
      put "${website-source.ftp}\*.as*x"
      put "${website-source.ftp}\*.css"
      put "${website-source.ftp}\*.js"
      put "${website-source.ftp}\layouts"
      put "${website-source.ftp}\xsl"
      put "${website-source.ftp}\js"
      put "${website-source.ftp}\ErrorPages"
      put "${website-source.ftp}\SearchUtils"
      put "${website-source.ftp}\WebServices"
      put "${website-source.ftp}\css"
      put "${website-source.ftp}\App_Config"
      bin
      put "${website-source.ftp}\bin"
      put "${website-source.ftp}\img"
    </echo>
    <echo file="${ftp.command.file}" append="true">
      ascii
      cd /${remotedir.ftp}/App_Config
      put "${env-config-source.ftp}\*.config"
    </echo>
    <echo file="${ftp.command.file}" append="true">
      exit
    </echo>

Executing the ftp.command.file

The next step is to execute the FTP Command file using the <exec/> task. Use the WinSCP.com executable instead of WinSCP.exe as that is the one intended for use in batch/non-interactive programs:

    <exec program="WinSCP.com" basedir="${sftp.exec.dir}" >
      <arg value="/script=${ftp.command.file}"/>
    </exec>

The only other challenge is to grab the Fingerprint key to be used as input for the -hostkey parameter. This can be done by connecting to the SFTP server from the WinSCP console interface and copying it using the "Copy Key" button below:

Securing Sitecore Content for Logged In Users

Thu, 01 Mar 2012 23:34:00 GMT

Securing content for a user that is logged in is a common request for sites where users enter sensitive information. With this in mind, we created a simple module that will always push the user to the secure version of the site when they are logged into Sitecore. All of this done is in the server side. Here is the code for this module:

using Sitecore.Pipelines.HttpRequest;

using Sitecore.Web;

namespace Oshyn.Sitecore.Pipeline.Security

{

public class SSLResolver : HttpRequestProcessor

{

private bool _activeSSL;

public virtual bool ActiveSSL

{

get { return this._activeSSL; }

set { this._activeSSL = value; }

}

public override void Process(HttpRequestArgs args)

{

if (ActiveSSL && !args.Context.Request.IsSecureConnection && Sitecore.Context.PageMode.IsNormal)

{

WebUtil.Redirect(args.Context.Request.Url.AbsoluteUri.Replace("http://", "https://"));

}

Once this is compiled in a library, the following configuration must be added to your web.config file in the <httpRequestBegin> pileine after the <processor type="Sitecore.Pipelines.HttpRequest.ItemResolver, Sitecore.Kernel"/> line:

<ActiveSSL>false</ActiveSSL>

</processor>

This is a simple module, built with the intention that you will add further improvements in order to make it fit your specific business rules. For example, you could configure it so it does not affect the editors of your site. Multiple options exist, but this module should be simple enough to allow you to add any functionality you need.