This section gives you explanations of some technical terms which are used throughout the documentation.

Container templates

Templates which are used to contain the UI components in a specific layout and display them on the portal page.

ConversationState

An object which stores all information about the state of the current user. This object also stores acquired attributes of an Identity which is a set of principals to identify a user.

Data container

An object which implements the physical data storage. It enables different types of backend (such as RDB, FS files) to be used as a storage for the JCR data. With the main Data Container, other storages for persisted Property Values can be configured and used. The eXo JCR persistent data container can work in two configuration modes.

Database Creator (DBCreator)

A service that is responsible for executing the DDL (Data Definition Language) script in runtime. A DDL script may contain templates for database name, username, and password which will be replaced by real values at execution time.

Drives

Customized workspaces which include:

eXo Cache

One which all applications on the top of eXo JCR need. This can rely on an org.exoplatform.services.cache.ExoCache instance managed by org.exoplatform.services.cache.CacheService.

eXoContainer

An object which behaves like a class loader that is responsible for loading services/components. The eXoContainer class is inherited by all the containers, including RootContainer, PortalContainer, and StandaloneContainer. It itself inherits from a PicoContainer framework which allows eXo to apply the IoC Inversion of Control principles.

External Plugin

One which allows adding configuration for services and components easily.

Folksonomy

A system of classification which is derived from the practice and a method of collaboratively creating and managing tags to annotate and categorize content. This practice is also known as collaborative tagging social classification social indexing and social tagging. For more details, see: http://en.wikipedia.org.

Gadgets

Web-based software components which are based on HTML, CSS, and JavaScript. They allow developers to easily write useful web applications that work anywhere on the web without modification. For more details, see: opensocial.org.

Groovy template

A template which is widely used in eXo UI framework. It leverages the usage of Groovy language, a scripting language for Java. The template file consists of HTML code and Groovy code blocks.

JCR WebDav

A service that allows accessing a JCR repository via WebDav.

JobSchedulerService

One which defines a job to execute a given number of times during a given period. It is a service that is in charge of unattended background executions commonly known for historical reasons as batch processing.

JodConverter (Java OpenDocument Converter)

A tool which converts documents into different office formats and vice versa.

JCR Item

One which may be a node or a property.

ListenerService

An event mechanism which allows triggering and listening to events under specific conditions inside eXo Platform. This mechanism is used in several places in eXo Platform, such as login/logout time, creating/updating users, and groups.

LockManager

One which stores lock objects, so it can give a lock object or can release it. Also, LockManager is responsible for removing Locks that live too long.

Namespace

The name of a node or property which may have a prefix delimited by a single ':' colon character. This name indicates the namespace of the item (Source: JSR-170) and is used to avoid the naming conflict.

Navigation node

A node which looks like a label of the link to page on the Navigation bar. By clicking a node, the page content is displayed. A node maps a URI and a portal page for the portal's navigation system.

Navigation

One which looks like a menu which is to help users visualize the site structure and to provide hyperlinks to other parts on a Portal. Thus, a bar which contains navigations is called the Navigation bar.

Node type

One which defines child nodes and properties which a node may (or must) have. Every node type has attributes, such as name, supertypes, mixin status, orderable child nodes status, property definitions, child node definitions and primary item name (Source: JSR-170).

Node

An element in the tree structure that makes up a repository. Each node may have zero or more child nodes and zero or more child properties. There is a single root node per workspace which has no parent. All other nodes have only one parent.

Organization listener

One which provides a mechanism to receive notifications via an organization listener, including UserEventListener, GroupEventListener and MembershipEventListener.

Organization management

A portlet that manages users groups and memberships. This portlet is often managed by administrators to set up permission for users and groups.

OrganizationService

A service that allows accessing the Organization model. This model is composed of users, groups, and memberships. It is the basis of eXo's personalization and authorizations and is used for all over the platform.

Path constraint

One which restricts the result node to a scope specified by a path expression. The following path constraints must be supported exact child nodes descendants and descendants or self (Source: JSR-170).

Permission

A permission settings control which actions users can or cannot perform within the portal and are set by the portal administrators. Permission types specify what a user can do within the portal.

Portal Page

A page which consists of one or more various portlets. Their layouts are defined by container templates. To display a portal page, this page must be mapped to a navigation node.

Portal skins

Graphic styles which display an attractive user interface. Each skin has its own characteristics with different backgrounds, icons, color, and more.

PortalContainer

A type of container which is created at the startup of the portal web application in the init method of the PortalController servlet.

Portlet

A web-based application that provides a specific piece of content to be included as part of a portal page. In other words, portlets are pluggable user interface components that provide a presentation layer to information systems. There are two following types of portlet:

Property constraint

One which may be specified by a query on the result nodes by way of property constraints (Source: JSR-170).

Property

An element in the tree structure that makes up a repository. Each property has only one parent node and has no child node.

Repository

One which holds references to one or more workspaces.

eXo REST framework

One which is used to make eXo services (for example, the components deployed inside eXo Container) simply and transparently accessible via HTTP in a RESTful manner. In other words, those services should be viewed as a set of REST Resources-endpoints of the HTTP request-response chain. Those services are called ResourceContainers.

RootContainer

A base container which plays an important role during the startup. However, it is recommended that it should not be used directly.

RTL Framework (Right To Left Framework)

A framework which handles the text orientation depending on the current locale settings. It consists of four components, including Groovy template, Stylesheet, Images, and Client java.

StandaloneContainer

One which is a context independent eXo Container. It is also used for unit tests.

Taxonomy

One which is used to sort documents to ease searches when browsing documents online.

Tree structure

One structure which is defined as a hierarchical structure with a set of linked nodes and properties.

Type constraint

One which specifies the common primary node type of the returned nodes plus possibly additional mixin types that they also must have. Type constraints are inheritance-sensitive in which specifying a constraint of node type x will include all nodes explicitly declared to be type x and all nodes of subtypes of x (Source: JSR-170).

Web Content

A textual, visual or aural content that is encountered as part of the user experiences on a website. It may include other things, such as texts images, sounds, videos, and animations.

Workspace

A container of single rooted tree which includes items.

See also

Before setting up a complete project/extension, you need to have knowledge of how to install a Maven project.

set MAVEN_OPTS=-Xshare:auto -Xms128M -Xmx1G -XX:MaxPermSize=256M

export MAVEN_OPTS="-Xshare:auto -Xms128M -Xmx1G -XX:MaxPermSize=256M"

See also

See also

public class ExoUtils {

  /**

  * Get a service from the portal container

  * @param type : component type

  * @return the concrete instance retrieved in the container using the type as key

  */

  public <T>T getService(Class<T> type) {

    return (T)ExoContainerContext.getCurrentContainer().getComponentInstanceOfType(type);

  }

}

OrganizationService orgService = ExoUtils.getService(OrganizationService.class)

<configuration xmlns="http://www.exoplatform.org/xml/ns/kernel_1_1.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.exoplatform.org/xml/ns/kernel_1_1.xsd http://www.exoplatform.org/xml/ns/kernel_1_1.xsd">

</configuration>

<component>

   <key>org.exoplatform.services.cms.CmsService</key>

   <type>org.exoplatform.services.cms.impl.CmsServiceImpl</type>

</component>

<component>

  <key>org.exoplatform.services.resources.LocaleConfigService</key>

  <type>org.exoplatform.services.resources.impl.LocaleConfigServiceImpl</type>

  <init-params>

    <value-param>

      <name>locale.config.file</name>

      <value>war:/conf/common/locales-config.xml</value>

    </value-param>

  </init-params>

</component>

package org.exoplatform.services.resources.impl;

public class LocaleConfigServiceImpl implements LocaleConfigService {

  public LocaleConfigServiceImpl(InitParams params, ConfigurationManager cmanager) throws Exception {

    configs_ = new HashMap<String, LocaleConfig>(10);

    String confResource = params.getValueParam("locale.config.file").getValue();

    InputStream is = cmanager.getInputStream(confResource);

    parseConfiguration(is);

  }

}

<component>

  <key>org.exoplatform.services.ldap.LDAPService</key>

  <type>org.exoplatform.services.ldap.impl.LDAPServiceImpl</type>

  <init-params>

    <object-param>

      <name>ldap.config</name>

      <description>Default ldap config</description>

      <object type="org.exoplatform.services.ldap.impl.LDAPConnectionConfig">

        <field name="providerURL"><string>ldaps://10.0.0.3:636</string></field>

        <field name="rootdn"><string>CN=Administrator,CN=Users,DC=exoplatform,DC=org</string></field>

        <field name="password"><string>exo</string></field>

        <field name="version"><string>3</string></field>

        <field name="minConnection"><int>5</int></field>

        <field name="maxConnection"><int>10</int></field>

        <field name="referralMode"><string>ignore</string></field>

        <field name="serverName"><string>active.directory</string></field>

      </object>

    </object-param>

  </init-params>

</component>

package org.exoplatform.services.ldap.impl;


public class LDAPServiceImpl implements LDAPService {

  // ...

  public LDAPServiceImpl(InitParams params) {

    LDAPConnectionConfig config = (LDAPConnectionConfig) params.getObjectParam("ldap.config").getObject();

    ...

  }

  // ...

}

package org.exoplatform.services.ldap.impl;


public class LDAPConnectionConfig {

  private String providerURL = "ldap://127.0.0.1:389";

  private String rootdn;

  private String password;

  private String version;

  private String authenticationType = "simple";

  private String serverName = "default";

  private int minConnection;

  private int maxConnection;

  private String referralMode = "follow";

  // ...

}

<external-component-plugins>

  <target-component>org.exoplatform.services.cms.taxonomy.TaxonomyService</target-component>

  <component-plugin>

    <name>predefinedTaxonomyPlugin</name>

    <set-method>addTaxonomyPlugin</set-method>

    <type>org.exoplatform.services.cms.taxonomy.impl.TaxonomyPlugin</type>

    <init-params><!-- ... --></init-params>

  </component-plugin>

</external-component-plugins>

<web-app>

  <display-name>my-portal</display-name>

    <listener>

      <listener-class>org.exoplatform.container.web.PortalContainerConfigOwner</listener-class>

    </listener>

  <!-- ... -->

</web-app>

<external-component-plugins>

  <target-component>org.exoplatform.container.definition.PortalContainerConfig</target-component>

  <component-plugin>

    <name>Change PortalContainer Definitions</name>

    <set-method>registerChangePlugin</set-method>

    <type>org.exoplatform.container.definition.PortalContainerDefinitionChangePlugin</type>

    <init-params>

      <object-param>

        <name>change</name>

        <object type="org.exoplatform.container.definition.PortalContainerDefinitionChange$AddDependencies">

        <field name="dependencies">

          <collection type="java.util.ArrayList">

            <value>

              <string>my-portal</string>

            </value>

            <value>

              <string>my-portal-resources</string>

            </value>              

          </collection>

        </field>

        </object>

      </object-param> 

      <value-param>

        <name>apply.default</name>

        <value>true</value>

      </value-param>       

    </init-params>

  </component-plugin>

</external-component-plugins>

<external-component-plugins>

  <!-- The full qualified name of the ResourceBundleService -->

  <target-component>org.exoplatform.services.resources.ResourceBundleService</target-component>

  <component-plugin>

    <!-- The name of the plugin -->

    <name>Sample ResourceBundle Plugin</name>

    <!-- The name of the method to call on the ResourceBundleService in order to register the ResourceBundles -->

    <set-method>addResourceBundle</set-method>

    <!-- The full qualified name of the BaseResourceBundlePlugin -->

    <type>org.exoplatform.services.resources.impl.BaseResourceBundlePlugin</type>

    <init-params>

      <!--values-param>

        <name>classpath.resources</name>

        <description>The resources that start with the following package name should be load from file system</description>

        <value>locale.portlet</value>

      </values-param-->

      <values-param>

        <name>init.resources</name>

        <description>Store the following resources into the db for the first launch </description>

        <value>locale.portal.sample</value>

      </values-param>

      <values-param>

        <name>portal.resource.names</name>

        <description>The properties files of the portal , those file will be merged

        into one ResoruceBundle properties </description>

        <value>locale.portal.sample</value>

      </values-param>

    </init-params>

  </component-plugin>

</external-component-plugins>

import javax.jcr.Session;


import org.exoplatform.services.jcr.RepositoryService;

import org.exoplatform.services.jcr.core.ManageableRepository;

import org.exoplatform.services.jcr.ext.common.SessionProvider;

import org.exoplatform.services.wcm.utils.WCMCoreUtils;


// For example

RepositoryService repositoryService = WCMCoreUtils.getService(RepositoryService.class);

ManageableRepository manageableRepository = repositoryService.getRepository(repository);

SessionProvider sessionProvider = WCMCoreUtils.getSessionProvider();

Session session = sessionProvider.getSession(workspace, manageableRepository);

RepositoryService repositoryService = (RepositoryService) container.getComponentInstanceOfType(RepositoryService.class);

Repository repository = repositoryService.getRepository("repositoryName");

// set current repository at initial time

RepositoryService repositoryService = (RepositoryService) container.getComponentInstanceOfType(RepositoryService.class);

repositoryService.setCurrentRepositoryName("repositoryName");

....

// retrieve and use this  repository

Repository repository = repositoryService.getCurrentRepository();

Context ctx = new InitialContext();

Repository repository =(Repository) ctx.lookup("repositoryName");

Credentials credentials = new SimpleCredentials("exo", "exo".toCharArray());


Session jcrSession = repository.login(credentials, "production");

Session jcrSession = repository.login("production");

String path = "/"; // put your node path here


Node node = (Node) session.getItem(path);