• Documentation >
• Content management >
• Content API >
• Browsing content

Browsing and viewing content

To retrieve a content item and its information, you need to make use of the ContentService.

The service should be injected into the constructor of your command or controller.

Content REST API

To learn how to load content items using the REST API, see REST API reference.

Console commands

To learn more about commands in Symfony, refer to Console Commands.

Viewing content metadata

ContentInfo

Basic content metadata is available through ContentInfo objects and their properties. This value object provides primitive fields, such as contentTypeId, publishedDate, or mainLocationId, as well as methods for retrieving selected properties.

You can also use it to request other Content-related value objects from various services:

// ...
use Ibexa\Contracts\Core\Repository\ContentService;

class ViewContentMetaDataCommand extends Command

// ...
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $contentInfo = $this->contentService->loadContentInfo($contentId);

        $output->writeln("Name: $contentInfo->name");
        $output->writeln('Last modified: ' . $contentInfo->modificationDate->format('Y-m-d'));
        $output->writeln('Published: ' . $contentInfo->publishedDate->format('Y-m-d'));
        $output->writeln("RemoteId: $contentInfo->remoteId");
        $output->writeln("Main Language: $contentInfo->mainLanguageCode");
        $output->writeln('Always available: ' . ($contentInfo->alwaysAvailable ? 'Yes' : 'No'));

ContentInfo is loaded from the ContentService (line 9). It provides you with basic content metadata such as modification and publication dates or main language code.

Retrieving content information in a controller

To retrieve content information in a controller, you also make use of the ContentService, but rendering specific elements (e.g. content information or Field values) is relegated to templates.

Locations

To get the Locations of a content item you need to make use of the LocationService:

        $locations = $this->locationService->loadLocations($contentInfo);

        foreach ($locations as $location) {
            $output->writeln('Location: ' . $location->pathString);

LocationService::loadLocations uses ContentInfo to get all the Locations of a content item. This method returns an array of Location value objects. For each Location, the code above prints out its pathString (the internal representation of the path).

URL Aliases

The URLAliasService additionally enables you to retrieve the human-readable URL alias of each Location.

URLAliasService::reverseLookup gets the Location's main URL alias:

        $locations = $this->locationService->loadLocations($contentInfo);

        foreach ($locations as $location) {
            $urlAlias = $this->urlAliasService->reverseLookup($location);
            $output->writeln('URL alias: ' . $urlAlias->path);
        }

Content type

You can retrieve the content type of a content item through the getContentType method of the ContentInfo object:

        $content = $this->contentService->loadContent($contentId);
        $output->writeln('Content type: ' . $content->getContentType()->getName());

Versions

To iterate over the versions of a content item, use the ContentService::loadVersions method, which returns an array of VersionInfo value objects.

        $versionInfos = $this->contentService->loadVersions($contentInfo);
        foreach ($versionInfos as $versionInfo) {
            $output->write("Version $versionInfo->versionNo");
            $output->write(' by ' . $versionInfo->getCreator()->getName());
            $output->writeln(' in ' . $versionInfo->getInitialLanguage()->name);
        }

You can additionally provide the loadVersions method with the version status to get only versions of a specific status, e.g.:

        $versionInfoArray = $this->contentService->loadVersions($contentInfo, VersionInfo::STATUS_ARCHIVED);

Note

Requesting version data may be impossible for an anonymous user. Make sure to authenticate as a user with sufficient permissions.

Relations

Content Relations are versioned. To list Relations to and from your content, you need to pass a VersionInfo object to the ContentService::loadRelations method. You can get the current version's VersionInfo using ContentService::loadVersionInfo.

        $versionInfo = $this->contentService->loadVersionInfo($contentInfo);
        $relations = $this->contentService->loadRelations($versionInfo);
        foreach ($relations as $relation) {
            $name = $relation->destinationContentInfo->name;
            $output->writeln('Relation to content ' . $name);
        }

You can also specify the version number as the second argument to get Relations for a specific version:

$versionInfo = $this->contentService->loadVersionInfo($contentInfo, 2);

loadRelations provides an array of Relation objects. Relation has two main properties: destinationContentInfo, and sourceContentInfo. It also holds the relation type, and the optional Field this relation is made with.

Owning user

You can use the getOwner method of the ContentInfo object to load the content item's owner as a User value object.

        $output->writeln('Owner: ' . $contentInfo->getOwner()->getName());

To get the creator of the current version and not the content item's owner, you need to use the creatorId property from the current version's VersionInfo object.

Section

You can find the Section to which a content item belongs through the getSection method of the ContentInfo object:

        $output->writeln('Section: ' . $contentInfo->getSection()->name);

Note

Note that requesting Section data may be impossible for an anonymous user. Make sure to authenticate as a user with sufficient permissions.

Object states

You can retrieve Object states of a content item using ObjectStateService::getContentState. You need to provide it with the Object state group. All Object state groups can be retrieved through loadObjectStateGroups.

        $stateGroups = $this->objectStateService->loadObjectStateGroups();
        foreach ($stateGroups as $stateGroup) {
            $state = $this->objectStateService->getContentState($contentInfo, $stateGroup);
            $output->writeln("Object state: $state->identifier");
        }

Viewing content with Fields

To retrieve the Fields of the selected content item, you can use the following command:

use Ibexa\Contracts\Core\Repository\ContentService;
use Ibexa\Contracts\Core\Repository\ContentTypeService;
use Ibexa\Contracts\Core\Repository\FieldTypeService;
    // ...
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $contentId = $input->getArgument('contentId');

        $content = $this->contentService->loadContent($contentId);
        $contentType = $this->contentTypeService->loadContentType($content->contentInfo->contentTypeId);

        foreach ($contentType->fieldDefinitions as $fieldDefinition) {
            $output->writeln('Field: ' . $fieldDefinition->identifier);
            $fieldType = $this->fieldTypeService->getFieldType($fieldDefinition->fieldTypeIdentifier);
            $field = $content->getFieldValue($fieldDefinition->identifier);
            $valueHash = $fieldType->toHash($field);
            $output->writeln('Value:');
            $output->writeln($valueHash);
        }

        return self::SUCCESS;
    }

}

Line 9 shows how ContentService::loadContent loads the content item provided to the command. Line 14 makes use of the ContentTypeService to retrieve the content type of the requested item.

Lines 12-19 iterate over Fields defined by the content type. For each Field they print out its identifier, and then using FieldTypeService retrieve the Field's value and print it out to the console.

Viewing content in different languages

The Repository is SiteAccess-aware, so languages defined by the SiteAccess are automatically taken into account when loading content.

To load a specific language, provide its language code when loading the content item:

$content = $this->contentService->loadContent($contentId, ['ger-DE']);

To load all languages as a prioritized list, use Language::ALL:

$contentService->loadContent($content->id, Language::ALL);

Getting all content in a subtree

To go through all the content items contained in a subtree, you need to use the LocationService.

    private function browseLocation(Location $location, OutputInterface $output, $depth = 0)
    {
        $output->writeln($location->contentInfo->name);

        $children = $this->locationService->loadLocationChildren($location);
        foreach ($children->locations as $child) {
            $this->browseLocation($child, $output, $depth + 1);
        }
    }

    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $locationId = $input->getArgument('locationId');

        $location = $this->locationService->loadLocation($locationId);
        $this->browseLocation($location, $output);

        return self::SUCCESS;
    }

loadLocation (line 15) returns a value object, here a Location.

LocationService::loadLocationChildren (line 5) returns a LocationList value object that you can iterate over.

Note

Refer to Searching for information on more complex search queries.

Getting parent Location

To get the parent Location of content, you first need to determine which Location is the main one, in case the content item has multiple Locations. You can do it through the getMainLocation method of the ContentInfo object.

Next, use the getParentLocation method of the Location object to access the parent Location:

$mainLocation = $contentInfo->getMainLocation();
$output->writeln("Parent Location: " . $mainLocation->getParentLocation()->pathString);

Getting content from a Location

When dealing with Location objects (and Trash objects), you can get access to content item directly using $location->getContent. In Twig this can also be accessed by location.content.

This is a lazy property. It will trigger loading of content when first used. In case of bulk of Locations coming from Search or Location Service, the Content will also be loaded in bulk for the whole Location result set.

Comparing content versions

You can compare two versions of a content item using the VersionComparisonService. The versions must have the same language.

For example, to get the comparison between the name Field of two versions:

$versionFrom = $this->contentService->loadVersionInfo($contentInfo, $versionFromId);
$versionTo = $this->contentService->loadVersionInfo($contentInfo, $versionToId);

$nameComparison = $this->comparisonService->compare($versionFrom, $versionTo)->getFieldValueDiffByIdentifier('name')->getComparisonResult();

getComparisonResult returns a ComparisonResult object, which depends on the Field Type being compared. In the example of a Text Line (ezstring) Field, it is an array of StringDiff objects.

Each diff contains a section of the Field to compare (e.g. a part of a text line) and its status, which can be "unchanged", "added" or "removed".