Customizing and Extending Content Fragments customizing-and-extending-content-fragments

Creating and Managing Content Fragments and Page Authoring with Content Fragments for further information about content fragments.

Managing Assets and Customizing and Extending Assets for further information about standard assets.

Content Fragment Models:

• Used for defining content fragments that hold structured content.
• Content fragment models define the structure of a content fragment when it is created.
• A fragment references the model; so changes to the model may/will impact any dependent fragments.
• Models are built-up of data types.
• Functions to add new variations, etc., have to update the fragment accordingly.

Content Fragment Templates:

• Used for defining simple content fragments.
• Templates define the (basic, text-only) structure of a content fragment when it is created.
• The template is copied to the fragment when it is created; so further changes to the template will not be reflected in existing fragments.
• Functions to add new variations, etc., have to update the fragment accordingly.
• Content fragment templates operate in a different manner to that of other templating mechanisms within the AEM ecosystem (e.g. page templates, etc.). Therefore they should be considered separately.
• When based on a template the MIME type of the content is managed on the actual content; this means that each element and variation can have a different MIME type.

All content is stored under the jcr:content/data node of the asset:

• The element data is stored under the master sub-node:

  jcr:content/data/master

• Variations are stored under a sub-node that carries the name of the variation:

  e.g. jcr:content/data/myvariation

• The data of each element is stored in the respective sub-node as a property with the element name:

  e.g. the content of element text is stored as property text on jcr:content/data/master

Metadata and associated content is stored below jcr:content/metadata

Except for the title and description, which are not considered traditional metadata and stored on jcr:content

All non-content information of a fragment (such as title, description, metadata, structure) is managed on the main asset exclusively.

The content of the first element of a fragment is mapped to the original rendition of the main asset.

• The variations (if there are any) of the first element are mapped to other renditions of the main asset.

Additional elements (if existing) are mapped to sub-assets of the main asset.

• The main content of these additional elements map to the original rendition of the respective sub-asset.
• Other variations (if applicable) of any additional elements map to other renditions of the respective sub-asset.

The component uses the fragmentPath property to reference the actual content fragment. The fragmentPath property is handled in the same manner as similar properties of other asset types; for example, when the content fragment is moved to another location.

The component allows you to select the variation to be displayed.

Additionally, a range of paragraphs can be selected to restrict the output; for example, this can be used for multi-column output.

The component allows in-between content:

• Here the component allows you to place other assets (images, etc.) in between the paragraphs of the referenced fragment.

  • For in-between content you need to:

    • be aware of the possibility of unstable references; in-between content (added when authoring a page) has no fixed relationship to the paragraph it is positioned next to, inserting a new paragraph (in the content fragment editor) before the position of the in-between content can lose the relative position
      • consider the additional parameters (such as like variation and paragraph filters) to avoid false positives in search results

Resource types

A list of sling:resourceTypes can be provided to define components that are used for rendering content fragments and where the background processing should be applied to.

Reference Properties

A list of properties can be configured to specify where the reference to the fragment is stored for the respective component.

The name of the property where the element(s) to be rendered is defined must be either element or elementNames.

The name of the property where the variation to be rendered is defined must be either variation or variationName.

If the output of multiple elements is supported (by using elementNames to specify multiple elements), the actual display mode is defined by property displayMode:

• If the value is singleText (and there is only one element configured) then the element is rendered as a text with in-between content, layout support, etc. This is the default for fragments where only one single element is rendered.
• Otherwise, a much more simple approach is used (could be called “form view”), where no in-between content is supported and the fragment content is rendered “as is”.

If the fragment is rendered for displayMode == singleText (implicitly or explicitly) the following additional properties come into play:

• paragraphScope defines whether all paragraphs, or only a range of paragraphs, should be rendered (values: all vs. range)
• if paragraphScope == range then the property paragraphRange defines the range of paragraphs to be rendered

Translations

Content Fragments are fully integrated with the AEM translation workflow. On an architectural level, this means:

• The individual translations of a content fragment are actually separate fragments; for example:

  • they are located under different language roots:

    /content/dam/<path>/en/<to>/<fragment>

    vs.

    /content/dam/<path>/de/<to>/<fragment>

  • but they share exactly the same relative path below the language root:

    /content/dam/<path>/en/<to>/<fragment>

    vs.

    /content/dam/<path>/de/<to>/<fragment>

• Besides the rule-based paths, there is no further connection between the different language versions of a content fragment; they are handled as two separate fragments, although the UI provides the means to navigate between the language variants.

Metadata schemas

• Content fragments (re)use the metadata schemas, that can be defined with standard assets.

CFM provides its own, specific schema:

/libs/dam/content/schemaeditors/forms/contentfragment

this can be extended if required.

The respective schema form is integrated with the fragment editor.

Fragment Template

FragmentTemplate

Use FragmentTemplate.createFragment() for creating a new fragment.

Resource templateOrModelRsc = resourceResolver.getResource("...");
FragmentTemplate tpl = templateOrModelRsc.adaptTo(FragmentTemplate.class);
ContentFragment newFragment = tpl.createFragment(parentRsc, "A fragment name", "A fragment description.");

This interface represents:

• either a content fragment model or content fragment template from which to create a content fragment,
• and (after the creation) the structural information of that fragment

This information can include:

• Access basic data (title, description)

• Access templates/models for the elements of the fragment:

  • List element templates
  • Get structural information for a given element
  • Access the element template (see ElementTemplate)

• Access templates for the variations of the fragment:

  • List variation templates
  • Get structural information for a given variation
  • Access the variation template (see VariationTemplate)

• Get initial associated content

Interfaces that represent important information:

• ElementTemplate

  • Get basic data (name, title)
  • Get initial element content

• VariationTemplate

  • Get basic data (name, title, description)

Content Fragment

ContentFragment

This interface allows you to work with a content fragment in an abstract way.

The interface provides you with the means to:

• Manage basic data (e.g. get name; get/set title/description)

• Access meta data

• Access elements:

  • List elements
  • Get elements by name
  • Create new elements (see Caveats)
  • Access element data (see ContentElement)

• List variations defined for the fragment

• Create new variations globally

• Manage associated content:

  • List collections
  • Add collections
  • Remove collections

• Access the fragment’s model or template

Interfaces that represent the prime elements of a fragment are:

• Content Element

  ContentElement
  

  • Get basic data (name, title, description)

  • Get/Set content

  • Access variations of an element:

    • List variations
    • Get variations by name
    • Create new variations (see Caveats)
    • Remove variations (see Caveats)
    • Access variation data (see ContentVariation)

  • Shortcut for resolving variations (applying some additional, implementation-specific fallback logic if the specified variation is not available for an element)

• Content Variation

  ContentVariation
  

  • Get basic data (name, title, description)
  • Get/Set content
  • Simple synchronization, based on last modified information

All three interfaces ( ContentFragment, ContentElement, ContentVariation) extend the Versionable interface, which adds versioning capabilities, required for content fragments:

• Create new version of the element
• List versions of the element
• Get the content of a specific version of the versioned element

ContentFragment can be adapted to:

• Resource - the underlying Sling resource; note that updating the underlying Resource directly, requires rebuilding the ContentFragment object.
• Asset - the DAM Asset abstraction that represents the content fragment; note that updating the Asset directly, requires rebuilding the ContentFragment object.

ContentElement can be adapted to:

• ElementTemplate - for accessing the element’s structural information.

FragmentTemplate can be adapted to:

• Resource - the Resource determining the referenced model or the original template that was copied;

  • changes made through the Resource are not automatically reflected in the FragmentTemplate.

Resource can be adapted to:

• ContentFragment
• FragmentTemplate

The API is implemented to provide functionality supported by the UI.

The entire API is designed to not persist changes automatically (unless otherwise noted in the API JavaDoc). So you will always have to commit the resource resolver of the respective request (or the resolver you are actually using).

Tasks that might require additional effort:

• Creating/removing new elements will not update the data structure of simple fragments (based on a fragment template).
• Creating new variations from ContentElement will not update the data structure (but creating them globally from ContentFragment will).
• Removing existing variations will not update the data structure.

filter.xml

The filter.xml for content fragment management is configured so that it does not overlap with the Assets core content package.

Starting a session

• A new version of the content fragment is created.
• Auto save is started.
• Cookies are set; these define the currently edited fragment and that there is an edit session open.

Finishing a session

• Auto save is stopped.

• Upon commit:

  • The last modified information is updated.
  • Cookies are removed.

• Upon rollback:

  • The version of the content fragment that was created when the edit session was started is restored.
  • Cookies are removed.

Editing

• All changes (auto save included) are done on the active content fragment - not in a separated, protected area.
• Therefore, those changes are reflected immediately on AEM pages that reference the respective content fragment

Entering a page

• Check if an editing session is already present; by checking the respective cookie.

  • If one exists, verify that the editing session was started for the content fragment that is currently being edited

    • If the current fragment, reestablish the session.
    • If not, try to cancel editing for the previously edited content fragment and remove cookies (no editing session present afterwards).

  • If no edit session exists, wait for the first change made by the user (see below).

• Check if the content fragment is already referenced on a page and display appropriate information if so.

Content change

• Whenever the user changes content and there is no edit session present, a new edit session is created (see Starting a session).

Leaving a page

• If an editing session is present and the changes have not been persisted, a modal confirmation dialog is shown to notify the user of potentially lost content and allow them to stay on the page.

Node: <conf-root>/settings/dam/cfm/jcr:content

Property Name: autoSaveInterval

Type: Long

Default: 600 (10 minutes); this is defined on /libs/settings/dam/cfm/jcr:content

Node: /conf/global/settings/dam/cfm/jcr:content

Property Name: autoSaveInterval

Type: Long

Value: 300 (5 minutes equates to 300 seconds)