DomainMapper.php

<?php
/**
 * File containing the DomainMapper class
 *
 * @copyright Copyright (C) 1999-2014 eZ Systems AS. All rights reserved.
 * @license http://www.gnu.org/licenses/gpl-2.0.txt GNU General Public License v2
 * @version //autogentag//
 */

namespace eZ\Publish\Core\Repository;

use eZ\Publish\API\Repository\Repository as RepositoryInterface;
use eZ\Publish\SPI\Persistence\Content\Language\Handler;

use eZ\Publish\Core\Repository\Values\Content\Content;
use eZ\Publish\Core\Repository\Values\Content\VersionInfo;
use eZ\Publish\API\Repository\Values\Content\ContentInfo;
use eZ\Publish\API\Repository\Values\ContentType\ContentType;
use eZ\Publish\API\Repository\Values\Content\Field;
use eZ\Publish\Core\Repository\Values\Content\Relation;
use eZ\Publish\API\Repository\Values\Content\Location as APILocation;
use eZ\Publish\Core\Repository\Values\Content\Location;

use eZ\Publish\SPI\Persistence\Content as SPIContent;
use eZ\Publish\SPI\Persistence\Content\Location as SPILocation;
use eZ\Publish\SPI\Persistence\Content\VersionInfo as SPIVersionInfo;
use eZ\Publish\SPI\Persistence\Content\ContentInfo as SPIContentInfo;
use eZ\Publish\SPI\Persistence\Content\Relation as SPIRelation;
use eZ\Publish\SPI\Persistence\Content\Location\CreateStruct as SPILocationCreateStruct;

use eZ\Publish\API\Repository\Exceptions\NotFoundException;
use eZ\Publish\Core\Base\Exceptions\InvalidArgumentException;
use eZ\Publish\Core\Base\Exceptions\InvalidArgumentValue;
use eZ\Publish\Core\Base\Exceptions\InvalidArgumentType;

use DateTime;

/**
 * DomainMapper is an internal service.
 *
 * @internal
 */
class DomainMapper
{
    /**
     * @var \eZ\Publish\SPI\Persistence\Content\Language\Handler
     */
    protected $contentLanguageHandler;

    /**
     * @var \eZ\Publish\API\Repository\Repository
     */
    protected $repository;

    /**
     * Setups service with reference to repository.
     *
     * @param \eZ\Publish\API\Repository\Repository $repository
     * @param \eZ\Publish\SPI\Persistence\Content\Language\Handler $contentLanguageHandler
     */
    public function __construct( RepositoryInterface $repository, Handler $contentLanguageHandler )
    {
        $this->repository = $repository;
        $this->contentLanguageHandler = $contentLanguageHandler;
    }

    /**
     * Builds a Content domain object from value object returned from persistence.
     *
     * @param \eZ\Publish\SPI\Persistence\Content $spiContent
     * @param \eZ\Publish\API\Repository\Values\ContentType\ContentType $contentType
     *
     * @return \eZ\Publish\Core\Repository\Values\Content\Content
     */
    public function buildContentDomainObject( SPIContent $spiContent, $contentType = null )
    {
        if ( $contentType === null )
        {
            $contentType = $this->repository->getContentTypeService()->loadContentType(
                $spiContent->versionInfo->contentInfo->contentTypeId
            );
        }

        return new Content(
            array(
                "internalFields" => $this->buildDomainFields( $spiContent->fields, $contentType ),
                "versionInfo" => $this->buildVersionInfoDomainObject( $spiContent->versionInfo )
            )
        );
    }

    /**
     * Returns an array of domain fields created from given array of SPI fields
     *
     * @param \eZ\Publish\SPI\Persistence\Content\Field[] $spiFields
     * @param \eZ\Publish\API\Repository\Values\ContentType\ContentType $contentType
     *
     * @return array
     */
    public function buildDomainFields( array $spiFields, ContentType $contentType )
    {
        $fieldIdentifierMap = array();
        foreach ( $contentType->getFieldDefinitions() as $fieldDefinitions )
        {
            $fieldIdentifierMap[$fieldDefinitions->id] = $fieldDefinitions->identifier;
        }

        /** @var \eZ\Publish\Core\Repository\FieldTypeService $fieldTypeService */
        $fieldTypeService = $this->repository->getFieldTypeService();

        $fields = array();
        foreach ( $spiFields as $spiField )
        {
            $fields[] = new Field(
                array(
                    "id" => $spiField->id,
                    "value" => $fieldTypeService->buildFieldType( $spiField->type )
                        ->fromPersistenceValue( $spiField->value ),
                    "languageCode" => $spiField->languageCode,
                    "fieldDefIdentifier" => $fieldIdentifierMap[$spiField->fieldDefinitionId]
                )
            );
        }

        return $fields;
    }

    /**
     * Builds a VersionInfo domain object from value object returned from persistence
     *
     * @param \eZ\Publish\SPI\Persistence\Content\VersionInfo $spiVersionInfo
     *
     * @return \eZ\Publish\Core\Repository\Values\Content\VersionInfo
     */
    public function buildVersionInfoDomainObject( SPIVersionInfo $spiVersionInfo )
    {
        $languageCodes = array();
        foreach ( $spiVersionInfo->languageIds as $languageId )
        {
            $languageCodes[] = $this->contentLanguageHandler->load( $languageId )->languageCode;
        }

        return new VersionInfo(
            array(
                "id" => $spiVersionInfo->id,
                "versionNo" => $spiVersionInfo->versionNo,
                "modificationDate" => $this->getDateTime( $spiVersionInfo->modificationDate ),
                "creatorId" => $spiVersionInfo->creatorId,
                "creationDate" => $this->getDateTime( $spiVersionInfo->creationDate ),
                "status" => $spiVersionInfo->status,
                "initialLanguageCode" => $spiVersionInfo->initialLanguageCode,
                "languageCodes" => $languageCodes,
                "names" => $spiVersionInfo->names,
                "contentInfo" => $this->buildContentInfoDomainObject( $spiVersionInfo->contentInfo )
            )
        );
    }

    /**
     * Builds a ContentInfo domain object from value object returned from persistence.
     *
     * @param \eZ\Publish\SPI\Persistence\Content\ContentInfo $spiContentInfo
     *
     * @return \eZ\Publish\API\Repository\Values\Content\ContentInfo
     */
    public function buildContentInfoDomainObject( SPIContentInfo $spiContentInfo )
    {
        return new ContentInfo(
            array(
                "id" => $spiContentInfo->id,
                "contentTypeId" => $spiContentInfo->contentTypeId,
                "name" => $spiContentInfo->name,
                "sectionId" => $spiContentInfo->sectionId,
                "currentVersionNo" => $spiContentInfo->currentVersionNo,
                "published" => $spiContentInfo->isPublished,
                "ownerId" => $spiContentInfo->ownerId,
                "modificationDate" => $spiContentInfo->modificationDate == 0 ?
                    null :
                    $this->getDateTime( $spiContentInfo->modificationDate ),
                "publishedDate" => $spiContentInfo->publicationDate == 0 ?
                    null :
                    $this->getDateTime( $spiContentInfo->publicationDate ),
                "alwaysAvailable" => $spiContentInfo->alwaysAvailable,
                "remoteId" => $spiContentInfo->remoteId,
                "mainLanguageCode" => $spiContentInfo->mainLanguageCode,
                "mainLocationId" => $spiContentInfo->mainLocationId
            )
        );
    }

    /**
     * Builds API Relation object from provided SPI Relation object
     *
     * @param \eZ\Publish\SPI\Persistence\Content\Relation $spiRelation
     * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $sourceContentInfo
     * @param \eZ\Publish\API\Repository\Values\Content\ContentInfo $destinationContentInfo
     *
     * @return \eZ\Publish\API\Repository\Values\Content\Relation
     */
    public function buildRelationDomainObject(
        SPIRelation $spiRelation,
        ContentInfo $sourceContentInfo,
        ContentInfo $destinationContentInfo
    )
    {
        $sourceFieldDefinitionIdentifier = null;
        if ( $spiRelation->sourceFieldDefinitionId !== null )
        {
            /** @var \eZ\Publish\Core\Repository\Values\ContentType\ContentType $contentType */
            $contentType = $this->repository->getContentTypeService()
                ->loadContentType( $sourceContentInfo->contentTypeId );
            // Note: getFieldDefinitionById() is not part of API
            $sourceFieldDefinitionIdentifier = $contentType
                ->getFieldDefinitionById( $spiRelation->sourceFieldDefinitionId )->identifier;
        }

        return new Relation(
            array(
                "id" => $spiRelation->id,
                "sourceFieldDefinitionIdentifier" => $sourceFieldDefinitionIdentifier,
                "type" => $spiRelation->type,
                "sourceContentInfo" => $sourceContentInfo,
                "destinationContentInfo" => $destinationContentInfo
            )
        );
    }

    /**
     * Builds domain location object from provided persistence location
     *
     * @param \eZ\Publish\SPI\Persistence\Content\Location $spiLocation
     *
     * @return \eZ\Publish\API\Repository\Values\Content\Location
     */
    public function buildLocationDomainObject( SPILocation $spiLocation )
    {
        // TODO: this is hardcoded workaround for missing ContentInfo on root location
        if ( $spiLocation->id == 1 )
            $contentInfo = new ContentInfo(
                array(
                    'id' => 0,
                    'name' => 'Top Level Nodes',
                    'sectionId' => 1,
                    'mainLocationId' => 1,
                    'contentTypeId' => 1,
                )
            );
        else
            $contentInfo = $this->repository->getContentService()->internalLoadContentInfo( $spiLocation->contentId );

        return new Location(
            array(
                'contentInfo' => $contentInfo,
                'id' => $spiLocation->id,
                'priority' => $spiLocation->priority,
                'hidden' => $spiLocation->hidden,
                'invisible' => $spiLocation->invisible,
                'remoteId' => $spiLocation->remoteId,
                'parentLocationId' => $spiLocation->parentId,
                'pathString' => $spiLocation->pathString,
                'depth' => $spiLocation->depth,
                'sortField' => $spiLocation->sortField,
                'sortOrder' => $spiLocation->sortOrder,
            )
        );
    }

    /**
     * Creates an array of SPI location create structs from given array of API location create structs
     *
     * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException
     *
     * @param \eZ\Publish\API\Repository\Values\Content\LocationCreateStruct $locationCreateStruct
     * @param \eZ\Publish\API\Repository\Values\Content\Location $parentLocation
     * @param mixed $mainLocation
     * @param mixed $contentId
     * @param mixed $contentVersionNo
     *
     * @return \eZ\Publish\SPI\Persistence\Content\Location\CreateStruct
     */
    public function buildSPILocationCreateStruct(
        $locationCreateStruct,
        APILocation $parentLocation,
        $mainLocation,
        $contentId,
        $contentVersionNo
    )
    {
        if ( $locationCreateStruct->priority !== null && !is_int( $locationCreateStruct->priority ) )
        {
            throw new InvalidArgumentValue( "priority", $locationCreateStruct->priority, "LocationCreateStruct" );
        }

        if ( !is_bool( $locationCreateStruct->hidden ) )
        {
            throw new InvalidArgumentValue( "hidden", $locationCreateStruct->hidden, "LocationCreateStruct" );
        }

        if ( $locationCreateStruct->remoteId !== null && ( !is_string( $locationCreateStruct->remoteId ) || empty( $locationCreateStruct->remoteId ) ) )
        {
            throw new InvalidArgumentValue( "remoteId", $locationCreateStruct->remoteId, "LocationCreateStruct" );
        }

        if ( $locationCreateStruct->sortField !== null && !$this->isValidLocationSortField( $locationCreateStruct->sortField ) )
        {
            throw new InvalidArgumentValue( "sortField", $locationCreateStruct->sortField, "LocationCreateStruct" );
        }

        if ( $locationCreateStruct->sortOrder !== null && !$this->isValidLocationSortOrder( $locationCreateStruct->sortOrder ) )
        {
            throw new InvalidArgumentValue( "sortOrder", $locationCreateStruct->sortOrder, "LocationCreateStruct" );
        }

        $remoteId = $locationCreateStruct->remoteId;
        if ( null === $remoteId )
        {
            $remoteId = $this->getUniqueHash( $locationCreateStruct );
        }
        else
        {
            try
            {
                $this->repository->getLocationService()->loadLocationByRemoteId( $remoteId );
                throw new InvalidArgumentException(
                    "\$locationCreateStructs",
                    "Another Location with remoteId '{$remoteId}' exists"
                );
            }
            catch ( NotFoundException $e )
            {
                // Do nothing
            }
        }

        return new SPILocationCreateStruct(
            array(
                "priority" => $locationCreateStruct->priority,
                "hidden" => $locationCreateStruct->hidden,
                // If we declare the new Location as hidden, it is automatically invisible
                // Otherwise it picks up visibility from parent Location
                // Note: There is no need to check for hidden status of parent, as hidden Location
                // is always invisible as well
                "invisible" => ( $locationCreateStruct->hidden === true || $parentLocation->invisible ),
                "remoteId" => $remoteId,
                "contentId" => $contentId,
                "contentVersion" => $contentVersionNo,
                // pathIdentificationString will be set in storage
                "pathIdentificationString" => null,
                "mainLocationId" => $mainLocation,
                "sortField" => $locationCreateStruct->sortField !== null ? $locationCreateStruct->sortField : Location::SORT_FIELD_NAME,
                "sortOrder" => $locationCreateStruct->sortOrder !== null ? $locationCreateStruct->sortOrder : Location::SORT_ORDER_ASC,
                "parentId" => $locationCreateStruct->parentLocationId
            )
        );
    }

    /**
     * Checks if given $sortField value is one of the defined sort field constants.
     *
     * @param mixed $sortField
     *
     * @return bool
     */
    public function isValidLocationSortField( $sortField )
    {
        switch ( $sortField )
        {
            case APILocation::SORT_FIELD_PATH:
            case APILocation::SORT_FIELD_PUBLISHED:
            case APILocation::SORT_FIELD_MODIFIED:
            case APILocation::SORT_FIELD_SECTION:
            case APILocation::SORT_FIELD_DEPTH:
            case APILocation::SORT_FIELD_CLASS_IDENTIFIER:
            case APILocation::SORT_FIELD_CLASS_NAME:
            case APILocation::SORT_FIELD_PRIORITY:
            case APILocation::SORT_FIELD_NAME:
            case APILocation::SORT_FIELD_MODIFIED_SUBNODE:
            case APILocation::SORT_FIELD_NODE_ID:
            case APILocation::SORT_FIELD_CONTENTOBJECT_ID:
                return true;
        }

        return false;
    }

    /**
     * Checks if given $sortOrder value is one of the defined sort order constants.
     *
     * @param mixed $sortOrder
     *
     * @return bool
     */
    public function isValidLocationSortOrder( $sortOrder )
    {
        switch ( $sortOrder )
        {
            case APILocation::SORT_ORDER_DESC:
            case APILocation::SORT_ORDER_ASC:
                return true;
        }

        return false;
    }

    /**
     * Validates given translated list $list, which should be an array of strings with language codes as keys.
     *
     * @throws \eZ\Publish\API\Repository\Exceptions\InvalidArgumentException
     *
     * @param mixed $list
     * @param string $argumentName
     *
     * @return void
     */
    public function validateTranslatedList( $list, $argumentName )
    {
        if ( !is_array( $list ) )
        {
            throw new InvalidArgumentType( $argumentName, "array", $list );
        }

        foreach ( $list as $languageCode => $translation )
        {
            $this->contentLanguageHandler->loadByLanguageCode( $languageCode );

            if ( !is_string( $translation ) )
            {
                throw new InvalidArgumentType( $argumentName . "['$languageCode']", "string", $translation );
            }
        }
    }

    /**
     * Returns \DateTime object from given $timestamp in environment timezone.
     *
     * This method is needed because constructing \DateTime with $timestamp will
     * return the object in UTC timezone.
     *
     * @param int $timestamp
     *
     * @return \DateTime
     */
    public function getDateTime( $timestamp )
    {
        $dateTime = new DateTime();
        $dateTime->setTimestamp( $timestamp );
        return $dateTime;
    }

    /**
     * Creates unique hash string for given $object.
     *
     * Used for remoteId.
     *
     * @param object $object
     *
     * @return string
     */
    public function getUniqueHash( $object )
    {
        return md5( uniqid( get_class( $object ), true ) );
    }
}