Creating a content type

As a developer, you make content types available to Jahia users by creating and deploying content type definitions.

• A content type definition is a declaration that defines the structure (made of simple properties or child objects) of a content type. A content type definition is stored in a CND file.
• A content type is a small structured piece of content that users add to a page for display in a browser or mobile device.

For example, in the Digitall demo site, the Rich text content type enables users to add rich text content to a site. The following code:

[tuto:mainContent] > jnt:content, jmix:editorialContent
- textfield (string, richtext)

Renders as:

You create content definitions either with the definition builder tool in Jahia Studio or by creating a CND file by hand in a text editor.

About definition files

A content type definition is defined in a .cnd definition file that is typically named definitions.cnd. CND stands for Compact Namespace and Node Type Definition and is an Apache Jackrabbit standard. For more details, see Node Type Notation on the Apache Jackrabbit site.

Specifying a namespace

The first step in creating a content definition is to define a namespace. The namespace ensures that your content definition does not conflict with other content definitions. Your namespace must be unique.

The namespace syntax consists of a prefix and URI pair.

<ns = 'http://namespace.com/ns'>

Where

• The prefix is usually a short character chain
• The URI can be any string but Jahia recommends using a URI pattern

Your prefix and URI should be unique to the system. Here are a few examples of Jahia namespaces.

<jnt = 'http://www.jahia.org/jahia/nt/1.0'>

<jmix = 'http://www.jahia.org/jahia/mix/1.0'>

<j = 'http://www.jahia.org/jahia/1.0'>

<mix = 'http://www.jcp.org/jcr/mix/1.0'>

<fcnt = 'http://www.jahia.org/jahia/fc/nt/1.0'>

<fcmix = 'http://www.jahia.org/jahia/fc/mix/1.0'>

Declaring a new content type

You declare a new content type in a single line. A definition is identified by a namespace and a name [namespace:name], as shown in the following example.

[cnt:mainContent]

Jahia has already configured a content definition for you: [jnt:content]. All content types should inherit from this content definition to be compatible with Jahia. You use the right-arrow symbol (>) to define inheritance. For example, to inherit from [jnt:content], your definition looks like this:

[cnt:mainContent] > jnt:content

Notice that the new content type has a different namespace than the Jahia namespace. This prevents mainContent from being in conflict with existing Jahia content definitions. Note that you use square brackets ([ ]) to declare new content types. Finally, if you want to make this content available in the Jahia interface you need to add the editorialContent mixin to its definition. For more information on mixins, see About mixins.

[cnt:mainContent] > jnt:content, jmix:editorialContent

With this simple declaration, you can already manipulate your content definition in Jahia. For example:

<tuto = 'http://jahia.tuto.com/tuto>

[tuto:mainContent] > jnt:content, jmix:editorialContent

Declaring properties

A property is a data field. Properties are defined for each nodeType in its definition declaration. Properties can be compared to fields in a database.

Property syntax

Each property has a name and a type: - field-name (type).

[cnt:mainContent]
- myfield (string)

The definition can also specify a selector: - name (type, selector[options]). The following example shows a field string that specifies a richtext selector. For more information on selectors, see Property selectors.

[cnt:mainContent] > jnt:content, mix:title, jmix:structuredContent
- myfield (string,richtext)

string ::= quoted_string | unquoted_string
quoted_string :: = "'" unquoted_string "'"
unquoted_string ::= [A-Za-z0-9:_]+

Property types

You can specify the following property types.

• string
• boolean
• weakreference: reference to a node in the JCR
• date
• double
• long

The following table shows examples of how some properties render in Content Editor.

Property selectors

After declaring a property, you add a property selector to specify the interface that displays to content authors for the property, such as a rich text field or a drop-down list. Properties can support different property selectors. This section describes property selectors available out-of-the-box.

The following table shows property selectors available for strings.

Note that the "choicelist" selector is not compatible with decimal values.

The following table shows property selectors available for date properties.

Property keywords

This section describes property keywords. Keywords are specified using the following syntax: - myfield (type) keyword. The following example shows the multiple keyword, which allows the myfield property to contain multiple values.

[cnt:mainContent] > jnt:content, mix:title, jmix:structuredContent
- myfield (double) multiple

The following table lists keywords that specify how content is indexed by Jahia.

Child node properties

Definition files also support child node properties. The following table and example show how to specify child nodes for a property.

For example, the following definition contains paragraph and article content types. The article content type can have several paragraphs as child nodes.

[jnt:paragraph] > jnt:content, mix:title

[jnt:article] > jnt:content, mix:title, jmix:structuredContent
        + * (jnt:paragraph)

This definition has the same content types, but article can only have three paragraphs as child nodes and the name of those nodes will be paragraph1, paragraph2 and paragraph3.

[jnt:paragraph] > jnt:content, mix:title
 
[jnt:article] > jnt:content, mix:title, jmix:structuredContent
        + paragraph1 (jnt:paragraph)
        + paragraph2 (jnt:paragraph)
        + paragraph3 (jnt:paragraph)

Declaring mixins

Mixins are abstract data types that provide a set of properties. A mixin can also define no property at all and can only serve as a flag to be applied on specific content types.

Mixin syntax

You declare a mixin using the following syntax.

[jmix:mixinName] mixin
- properties
+ child

You use the following syntax to add a mixin to a content type definition

[jnt:contentType] > jnt:content, mixin1, mixin2

Category mixins

To make a content type available to editors, you apply a category mixin. Category mixins allow you to group your content definitions in different categories. Jahia provides different categories out-of-the-box and also allows you to create your own.

Here are a few category mixins that are available out of the box. This list is not exhaustive.

Default Jahia category mixins

The following image shows how the default category mixins display for users.

Creating your own category mixin

It is highly recommended that you create new categories when creating new content types, . This way, you will have a visible separation between Jahia's components and yours.

To create a new category mixin, you simply need to create a mixin inheriting from jmix:droppable content. The following example shows a new component category named "tutorialComponents".

<tutomix = 'http://jahia.tuto.com/tuto/mix>

[tutomix:tutorialComponents] > jmix:droppableContent mixin

Key mixins

Other mixins