• Templating and Integration Guide
  • Part 1: Concepts
    • The "Everything is Content" Paradigm
      • Content items are objects with properties that correspond to a type
      • Nodes are stored in workspaces, organized in trees
    • The rendering flow
      • To render a node, you need a view
      • To render a page, you need a template
    • Modules are packages used to deploy “code” into Jahia
    • The Jahia actors
      • Content flow
  • Part 2: Modules
    • What is a module?
    • Module type
    • Module creation
    • Anatomy of a module
    • Adding classes and Jars in modules
    • Spring files
  • Part 3: Templates and Studio
    • Introduction to templates
    • Studio
      • Studio overview
    • Creating a template-set
      • Using the Maven archetype
      • Using Eclipse
      • Using Jahia Studio
      • Update the Maven project when templates are modified in the Studio
    • Building templates
      • There are 3 different kind of templates
      • Main Resource and template resolution
      • Areas in detail
      • Content templates in details
      • Bound Components
    • CSS style sheets and design
      • Preparing your stylesheet
      • Including stylesheets in templates
      • Managing different stylesheets depending on the context
      • Print friendly CSS
      • CSS frameworks and handmade XHTML
    • Themes
      • How it works
    • Skins
      • Creating skins
      • Skin rendering
  • Part 4: Content Definitions and Views
    • Definitons
      • NodeType
      • Namespaces
      • Supertypes
      • Options
      • Node Type properties
      • Input masks
      • Default values
      • Initializers
      • Validators
      • Abstract types
      • In practice: create the node type definition for dogs
    • Views
      • NodeType folders
      • Output formats
      • Default view
      • Other views
      • Modules versus Components
      • Module packaging and deployement
    • Managing URLs in scripts
    • Managing lists
      • Summary for a simple list
      • Using list views
    • Managing and customizing navigation menus
      • Menu Rendering
      • Customization
  • Part 5: Advanced Techniques
    • Search and queries
      • Full text queries using search tag libraries
      • Queries
      • In practice: creating a custom search component
    • Forms
      • Principles
      • Form data parameters
      • In practice: Transform a custom HTML form into a Jahia valid form step by step
    • Macros
      • Macro implementation languages
      • Typical usage
    • Caches
  • Part 6: Setting up an integration environment
    • Software Requirements
    • Maven configuration for Eclipse IDE
    • Maven External Configuration
    • Creating a template set
  • Part 7: Step by step integration
    • Cutting of the mockup
    • Integration of the Base
    • CSS / Javascript integration
    • Creating the content zones
  • Further reading and resources

The Jahia actors

Let’s have a look at the global flow of content in the web layer (the top layer of the software) to understand what are the different actors and how you, as a developer, have responsibilities’.

Editors will login to the system and start creating sites, pages and other content types that were specified by the developers. They use Jahia’s Edit mode or the simpler Contribute mode to submit content and build the site bit by bit. As they enter content, rules, actions are used to perform logic actions upon submission; and then templates, scripts and finally macros are used to output the resulting HTML.

Visitors will surf anonymously or login to the system, browse the site and interact with any dynamic object types that the editors and developers have made available to them. An example of such a dynamic object could be a forum, or a comment list. The content they contribute is called “User Generated Content” (or UGC). Again, Jahia will use the templates, scripts and macros to render the pages for the visitors, and if they are allowed to enter content, rules, actions and content definitions will again come into play (but not illustrated above to keep the diagram simple).

Developers, integrators and webmasters will mostly interact with the studio as well as modules to create templates so that the other users may use a system that has been customized to their needs. In this role, this will enable them to « lock » the look and feel of the web site, as well as the content definitions, rules or any other custom logic needed.

Webmasters and/or editors will then use the output of the previous work to populate the site with content, using the edit mode and/or the contribute mode. The edit mode is a really powerful content editing interface, mostly targeted at advanced users, while the contribute mode is an easy-to-use content editing interface aimed at basic content editors. It should also be noted that integrators are free to customize the contribute mode to their requirements, in order to tailor the experience for the editors. Once the editors are happy with the content, they may use the workflow to publish the modifications to the live workspace (or if they are not directly allowed to do so, they may start the review process), at which point it will be available to site visitors.

Site visitors may then browse the site, and if allowed, also input user-generated content in modules such as the forum, wiki or another other components deployed in the site.