AbstractObject::updateLocator() - Code Metrics - Inspection of "Added extra method for loading the initial draft o..." - apparat/object - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 108e84...f077fb )

by Joschi

created 2016-08-01 08:42 UTC

AbstractObject::updateLocator() A

↳ Parent: AbstractObject

Complexity

Conditions	3
Paths	1

Size

Total Lines	9
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	3

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
eloc	7
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	9
ccs	8
cts	8
cp	1
crap	3
rs	9.6666

<?php

/**
 * apparat-object
 *
 * @category    Apparat
 * @package     Apparat\Object
 * @subpackage  Apparat\Object\Domain
 * @author      Joschi Kuphal <[email protected]> / @jkphl
 * @copyright   Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
 * @license     http://opensource.org/licenses/MIT The MIT License (MIT)
 */

/***********************************************************************************
 *  The MIT License (MIT)
 *
 *  Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy of
 *  this software and associated documentation files (the "Software"), to deal in
 *  the Software without restriction, including without limitation the rights to
 *  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 *  the Software, and to permit persons to whom the Software is furnished to do so,
 *  subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in all
 *  copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 *  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 *  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 *  IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 *  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ***********************************************************************************/

namespace Apparat\Object\Domain\Model\Object;

use Apparat\Kernel\Ports\Kernel;
use Apparat\Object\Domain\Model\Object\Traits\DomainPropertiesTrait;
use Apparat\Object\Domain\Model\Object\Traits\IterableTrait;
use Apparat\Object\Domain\Model\Object\Traits\MetaPropertiesTrait;
use Apparat\Object\Domain\Model\Object\Traits\PayloadTrait;
use Apparat\Object\Domain\Model\Object\Traits\ProcessingInstructionsTrait;
use Apparat\Object\Domain\Model\Object\Traits\RelationsTrait;
use Apparat\Object\Domain\Model\Object\Traits\StatesTrait;
use Apparat\Object\Domain\Model\Object\Traits\SystemPropertiesTrait;
use Apparat\Object\Domain\Model\Properties\AbstractDomainProperties;
use Apparat\Object\Domain\Model\Properties\InvalidArgumentException as PropertyInvalidArgumentException;
use Apparat\Object\Domain\Model\Properties\MetaProperties;
use Apparat\Object\Domain\Model\Properties\ProcessingInstructions;
use Apparat\Object\Domain\Model\Properties\Relations;
use Apparat\Object\Domain\Model\Properties\SystemProperties;
use Apparat\Object\Domain\Model\Uri\RepositoryLocator;
use Apparat\Object\Domain\Model\Uri\RepositoryLocatorInterface;
use Apparat\Object\Domain\Repository\SelectorInterface;
use Apparat\Object\Domain\Repository\Service;

/**
 * Abstract object
 *
 * @package Apparat\Object
 * @subpackage Apparat\Object\Domain
 */
abstract class AbstractObject implements ObjectInterface
{
    /**
     * Use traits
     */
    use SystemPropertiesTrait, MetaPropertiesTrait, DomainPropertiesTrait, RelationsTrait,
        ProcessingInstructionsTrait, PayloadTrait, IterableTrait, StatesTrait;

    /**
     * Repository locator
     *
     * @var RepositoryLocatorInterface
     */
    protected $locator;
    /**
     * Latest revision
     *
     * @var Revision
     */
    protected $latestRevision;

    /**
     * Object constructor
     *
     * @param RepositoryLocatorInterface $locator Object repository locator
     * @param string $payload Object payload
     * @param array $propertyData Property data
     */
    public function __construct(RepositoryLocatorInterface $locator, $payload = '', array $propertyData = [])
    {
        // If the domain property collection class is invalid
        if (!$this->domainPropertyCClass
            || !class_exists($this->domainPropertyCClass)
            || !(new \ReflectionClass($this->domainPropertyCClass))->isSubclassOf(AbstractDomainProperties::class)
        ) {
            throw new PropertyInvalidArgumentException(
                sprintf(
                    'Invalid domain property collection class "%s"',
                    $this->domainPropertyCClass
                ),
                PropertyInvalidArgumentException::INVALID_DOMAIN_PROPERTY_COLLECTION_CLASS
            );
        }

        // Save the original object locator
        $this->locator = $locator;

        // Load the current revision data
        $this->loadRevisionData($payload, $propertyData);

        // Determine the latest revision number (considering a possible draft)
        $this->latestRevision = $this->hasDraft()
            ? Kernel::create(Revision::class, [$this->getRevision()->getRevision() + 1, true])
            : $this->getRevision();

        // Update the object locator
        $this->updateLocator();
    }

    /**
     * Load object revision data
     *
     * @param string $payload Object payload
     * @param array $propertyData Property data
     */
    protected function loadRevisionData($payload = '', array $propertyData = [])
    {
        $this->payload = $payload;

        // Instantiate the system properties
        $systemPropertyData = (empty($propertyData[SystemProperties::COLLECTION]) ||
            !is_array(
                $propertyData[SystemProperties::COLLECTION]
            )) ? [] : $propertyData[SystemProperties::COLLECTION];
        $this->systemProperties = Kernel::create(SystemProperties::class, [$systemPropertyData, $this]);

        // Instantiate the meta properties
        $metaPropertyData = (empty($propertyData[MetaProperties::COLLECTION]) ||
            !is_array(
                $propertyData[MetaProperties::COLLECTION]
            )) ? [] : $propertyData[MetaProperties::COLLECTION];
        /** @var MetaProperties $metaProperties */
        $metaProperties = Kernel::create(MetaProperties::class, [$metaPropertyData, $this]);
        $this->setMetaProperties($metaProperties, true);

        // Instantiate the domain properties
        $domainPropertyData = (empty($propertyData[AbstractDomainProperties::COLLECTION]) ||
            !is_array(
                $propertyData[AbstractDomainProperties::COLLECTION]
            )) ? [] : $propertyData[AbstractDomainProperties::COLLECTION];
        /** @var AbstractDomainProperties $domainProperties */
        $domainProperties = Kernel::create($this->domainPropertyCClass, [$domainPropertyData, $this]);
        $this->setDomainProperties($domainProperties, true);

        // Instantiate the processing instructions
        $procInstData = (empty($propertyData[ProcessingInstructions::COLLECTION]) ||
            !is_array(
                $propertyData[ProcessingInstructions::COLLECTION]
            )) ? [] : $propertyData[ProcessingInstructions::COLLECTION];
        /** @var ProcessingInstructions $procInstCollection */
        $procInstCollection = Kernel::create(ProcessingInstructions::class, [$procInstData, $this]);
        $this->setProcessingInstructions($procInstCollection, true);

        // Instantiate the object relations
        $relationData = (empty($propertyData[Relations::COLLECTION]) ||
            !is_array(
                $propertyData[Relations::COLLECTION]
            )) ? [] : $propertyData[Relations::COLLECTION];
        /** @var Relations $relationCollection */
        $relationCollection = Kernel::create(Relations::class, [$relationData, $this]);
        $this->setRelations($relationCollection, true);

        // Reset the object state
        $this->resetState();
    }

    /**
     * Return whether this object already has a draft revision
     *
     * @return bool Whether this object has a draft revision
     */
    protected function hasDraft()
    {
        // Create the object draft resource locator
        $draftLocator = $this->locator->setRevision(Revision::current(true));

        // Use the object manager to look for a draft resource
        /** @var ManagerInterface $objectManager */
        $objectManager = Kernel::create(Service::class)->getObjectManager();
        return $objectManager->objectResourceExists($draftLocator);
    }

    /**
     * Update the object locator
     */
    protected function updateLocator()
    {
        $revision = $this->getRevision();
        $this->locator = $this->locator->setRevision(
            !$revision->isDraft() && ($this->getCurrentRevision()->getRevision() == $revision->getRevision())
                ? Revision::current($revision->isDraft())
                : $revision
        )->setHidden($this->isDeleted());
    }

    /**
     * Return this object's current revision
     *
     * @return Revision Current revision
     */
    protected function getCurrentRevision()
    {
        if ($this->latestRevision->isDraft() && ($this->latestRevision->getRevision() > 1)) {
            return Kernel::create(Revision::class, [$this->latestRevision->getRevision() - 1, false]);
        }
        return $this->latestRevision;
    }

    /**
     * Use a specific object revision
     *
     * @param Revision $revision Revision to be used
     * @return ObjectInterface Object
     * @throws OutOfBoundsException If a revision beyond the latest one is requested
     */
    public function useRevision(Revision $revision)
    {
        // If a revision beyond the latest one is requested
        if (!$revision->isCurrent() && ($revision->getRevision() > $this->latestRevision->getRevision())) {
            throw new OutOfBoundsException(
                sprintf('Invalid object revision "%s"', $revision->getRevision()),
                OutOfBoundsException::INVALID_OBJECT_REVISION
            );
        }

        // Determine whether the current revision was requested
        $currentRevision = $this->getCurrentRevision();
        $isCurrentRevision = $revision->isCurrent() || $currentRevision->equals($revision);
        if ($isCurrentRevision) {
            $revision = $currentRevision;
        }

        // If the requested revision is not already used
        if (!$this->getRevision()->equals($revision)) {

            /** @var ManagerInterface $objectManager */
            $objectManager = Kernel::create(Service::class)->getObjectManager();
            /** @var Revision $newRevision */
            $newRevision = $isCurrentRevision ? Revision::current() : $revision;
            /** @var RepositoryLocator $newRevisionLocator */
            $newRevisionLocator = $this->locator->setRevision($newRevision);

            // Instantiate the requested revision resource
            $revisionResource = $objectManager->loadObjectResource($newRevisionLocator, SelectorInterface::ALL);

            // Load the revision resource data
            $this->loadRevisionData($revisionResource->getPayload(), $revisionResource->getPropertyData());

            // Update the object locator
            $this->updateLocator();
        }

        return $this;
    }

    /**
     * Return the object repository locator
     *
     * @return RepositoryLocatorInterface Object repository locator
     */
    public function getRepositoryLocator()
    {
        return $this->locator;
    }

    /**
     * Return the object property data
     *
     * @param bool $serialize Serialize property objects
     * @return array Object property data
     */
    public function getPropertyData($serialize = true)
    {
        $propertyData = array_filter([
            SystemProperties::COLLECTION => $this->systemProperties->toArray($serialize),
            MetaProperties::COLLECTION => $this->metaProperties->toArray($serialize),
            AbstractDomainProperties::COLLECTION => $this->domainProperties->toArray($serialize),
            ProcessingInstructions::COLLECTION => $this->processingInstructions->toArray($serialize),
            Relations::COLLECTION => $this->relations->toArray($serialize),
        ], function (array $collection) {
            return (boolean)count($collection);
        });

        return $propertyData;
    }

    /**
     * Return the absolute object URL
     *
     * @return string
     */
    public function getAbsoluteUrl()
    {
        return getenv('APPARAT_BASE_URL').rtrim($this->locator->getRepository()->getUrl(), '/').strval($this->locator);
    }

    /**
     * Return the canonical object URL
     *
     * @return string
     */
    public function getCanonicalUrl()
    {
        $canonicalLocator = $this->locator->setRevision(Revision::current());
        $canonicalUrl = ltrim($this->locator->getRepository()->getUrl(), '/').strval($canonicalLocator);
        return getenv('APPARAT_BASE_URL').$canonicalUrl;
    }

    /**
     * Persist the current object revision
     *
     * @return ObjectInterface Object
     */
    public function persist()
    {
        // If this is not the latest revision
        if ($this->getRevision()->getRevision() !== $this->latestRevision->getRevision()) {
            throw new RuntimeException(
                sprintf(
                    'Cannot persist revision %s/%s',
                    $this->getRevision()->getRevision(),
                    $this->latestRevision->getRevision()
                ),
                RuntimeException::CANNOT_PERSIST_EARLIER_REVISION
            );
        }

        // Update the object repository
        $this->locator->getRepository()->updateObject($this);

        // Reset to a clean state
        $this->resetState();
        $this->latestRevision = $this->getRevision();
        $this->updateLocator();

        // Post persistence hook
        $this->postPersist();

        return $this;
    }

    /**
     * Post persistence hook
     *
     * @return void
     */
    protected function postPersist()
    {
    }

    /**
     * Publish the current object revision
     *
     * @return ObjectInterface Object
     */
    public function publish()
    {
        // If this is an unpublished draft
        if ($this->isDraft() & !$this->hasBeenPublished()) {
            $this->setPublishedState();
            $this->latestRevision = $this->latestRevision->setDraft(false);
            $this->updateLocator();
        }

        return $this;
    }

    /**
     * Delete the object and all its revisions
     *
     * @return ObjectInterface Object
     */
    public function delete()
    {
        // If this object is not already deleted
        if (!$this->isDeleted() && !$this->hasBeenDeleted()) {
            $this->setDeletedState();
            $this->updateLocator();
        }

        return $this;
    }

    /**
     * Undelete the object and all its revisions
     *
     * @return ObjectInterface Object
     */
    public function undelete()
    {
        // If this object is already deleted
        if ($this->isDeleted() && !$this->hasBeenUndeleted()) {
            $this->setUndeletedState();
            $this->updateLocator();
        }

        return $this;
    }

    /**
     * Convert this object revision into a draft
     */
    protected function convertToDraft()
    {
        // Assume the latest revision as draft revision
        $draftRevision = $this->latestRevision;

        // If it equals the current revision: Spawn a draft
        if ($draftRevision->equals($this->getCurrentRevision())) {
            $draftRevision = $this->latestRevision = $draftRevision->increment()->setDraft(true);
        }

        // Set the system properties to draft mode
        $this->setSystemProperties($this->systemProperties->createDraft($draftRevision), true);

        // Update the object locator
        $this->updateLocator();
    }
}


1		<?php
2
3		/**
4		* apparat-object
5		*
6		* @category Apparat
7		* @package Apparat\Object
8		* @subpackage Apparat\Object\Domain
9		* @author Joschi Kuphal <[email protected]> / @jkphl
10		* @copyright Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
11		* @license http://opensource.org/licenses/MIT The MIT License (MIT)
12		*/
13
14		/***********************************************************************************
15		* The MIT License (MIT)
16		*
17		* Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
18		*
19		* Permission is hereby granted, free of charge, to any person obtaining a copy of
20		* this software and associated documentation files (the "Software"), to deal in
21		* the Software without restriction, including without limitation the rights to
22		* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
23		* the Software, and to permit persons to whom the Software is furnished to do so,
24		* subject to the following conditions:
25		*
26		* The above copyright notice and this permission notice shall be included in all
27		* copies or substantial portions of the Software.
28		*
29		* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
30		* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
31		* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
32		* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
33		* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
34		* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35		***********************************************************************************/
36
37		namespace Apparat\Object\Domain\Model\Object;
38
39		use Apparat\Kernel\Ports\Kernel;
40		use Apparat\Object\Domain\Model\Object\Traits\DomainPropertiesTrait;
41		use Apparat\Object\Domain\Model\Object\Traits\IterableTrait;
42		use Apparat\Object\Domain\Model\Object\Traits\MetaPropertiesTrait;
43		use Apparat\Object\Domain\Model\Object\Traits\PayloadTrait;
44		use Apparat\Object\Domain\Model\Object\Traits\ProcessingInstructionsTrait;
45		use Apparat\Object\Domain\Model\Object\Traits\RelationsTrait;
46		use Apparat\Object\Domain\Model\Object\Traits\StatesTrait;
47		use Apparat\Object\Domain\Model\Object\Traits\SystemPropertiesTrait;
48		use Apparat\Object\Domain\Model\Properties\AbstractDomainProperties;
49		use Apparat\Object\Domain\Model\Properties\InvalidArgumentException as PropertyInvalidArgumentException;
50		use Apparat\Object\Domain\Model\Properties\MetaProperties;
51		use Apparat\Object\Domain\Model\Properties\ProcessingInstructions;
52		use Apparat\Object\Domain\Model\Properties\Relations;
53		use Apparat\Object\Domain\Model\Properties\SystemProperties;
54		use Apparat\Object\Domain\Model\Uri\RepositoryLocator;
55		use Apparat\Object\Domain\Model\Uri\RepositoryLocatorInterface;
56		use Apparat\Object\Domain\Repository\SelectorInterface;
57		use Apparat\Object\Domain\Repository\Service;
58
59		/**
60		* Abstract object
61		*
62		* @package Apparat\Object
63		* @subpackage Apparat\Object\Domain
64		*/
65		abstract class AbstractObject implements ObjectInterface
66		{
67		/**
68		* Use traits
69		*/
70		use SystemPropertiesTrait, MetaPropertiesTrait, DomainPropertiesTrait, RelationsTrait,
71		ProcessingInstructionsTrait, PayloadTrait, IterableTrait, StatesTrait;
72
73		/**
74		* Repository locator
75		*
76		* @var RepositoryLocatorInterface
77		*/
78		protected $locator;
79		/**
80		* Latest revision
81		*
82		* @var Revision
83		*/
84		protected $latestRevision;
85
86		/**
87		* Object constructor
88		*
89		* @param RepositoryLocatorInterface $locator Object repository locator
90		* @param string $payload Object payload
91		* @param array $propertyData Property data
92		*/
93	47	public function __construct(RepositoryLocatorInterface $locator, $payload = '', array $propertyData = [])
94		{
95		// If the domain property collection class is invalid
96	47	if (!$this->domainPropertyCClass
97	47	\|\| !class_exists($this->domainPropertyCClass)
98	47	\|\| !(new \ReflectionClass($this->domainPropertyCClass))->isSubclassOf(AbstractDomainProperties::class)
99		) {
100	1	throw new PropertyInvalidArgumentException(
101		sprintf(
102	1	'Invalid domain property collection class "%s"',
103	1	$this->domainPropertyCClass
104		),
105	1	PropertyInvalidArgumentException::INVALID_DOMAIN_PROPERTY_COLLECTION_CLASS
106		);
107		}
108
109		// Save the original object locator
110	46	$this->locator = $locator;
111
112		// Load the current revision data
113	46	$this->loadRevisionData($payload, $propertyData);
114
115		// Determine the latest revision number (considering a possible draft)
116	45	$this->latestRevision = $this->hasDraft()
117		? Kernel::create(Revision::class, [$this->getRevision()->getRevision() + 1, true])
118	45	: $this->getRevision();
119
120		// Update the object locator
121	45	$this->updateLocator();
122	45	}
123
124		/**
125		* Load object revision data
126		*
127		* @param string $payload Object payload
128		* @param array $propertyData Property data
129		*/
130	46	protected function loadRevisionData($payload = '', array $propertyData = [])
131		{
132	46	$this->payload = $payload;
133
134		// Instantiate the system properties
135	46	$systemPropertyData = (empty($propertyData[SystemProperties::COLLECTION]) \|\|
136	46	!is_array(
137	46	$propertyData[SystemProperties::COLLECTION]
138	46	)) ? [] : $propertyData[SystemProperties::COLLECTION];
139	46	$this->systemProperties = Kernel::create(SystemProperties::class, [$systemPropertyData, $this]);
140
141		// Instantiate the meta properties
142	45	$metaPropertyData = (empty($propertyData[MetaProperties::COLLECTION]) \|\|
143	45	!is_array(
144	45	$propertyData[MetaProperties::COLLECTION]
145	45	)) ? [] : $propertyData[MetaProperties::COLLECTION];
146		/** @var MetaProperties $metaProperties */
147	45	$metaProperties = Kernel::create(MetaProperties::class, [$metaPropertyData, $this]);
148	45	$this->setMetaProperties($metaProperties, true);
149
150		// Instantiate the domain properties
151	45	$domainPropertyData = (empty($propertyData[AbstractDomainProperties::COLLECTION]) \|\|
152	37	!is_array(
153	45	$propertyData[AbstractDomainProperties::COLLECTION]
154	45	)) ? [] : $propertyData[AbstractDomainProperties::COLLECTION];
155		/** @var AbstractDomainProperties $domainProperties */
156	45	$domainProperties = Kernel::create($this->domainPropertyCClass, [$domainPropertyData, $this]);
157	45	$this->setDomainProperties($domainProperties, true);
158
159		// Instantiate the processing instructions
160	45	$procInstData = (empty($propertyData[ProcessingInstructions::COLLECTION]) \|\|
161	31	!is_array(
162	45	$propertyData[ProcessingInstructions::COLLECTION]
163	45	)) ? [] : $propertyData[ProcessingInstructions::COLLECTION];
164		/** @var ProcessingInstructions $procInstCollection */
165	45	$procInstCollection = Kernel::create(ProcessingInstructions::class, [$procInstData, $this]);
166	45	$this->setProcessingInstructions($procInstCollection, true);
167
168		// Instantiate the object relations
169	45	$relationData = (empty($propertyData[Relations::COLLECTION]) \|\|
170	38	!is_array(
171	45	$propertyData[Relations::COLLECTION]
172	45	)) ? [] : $propertyData[Relations::COLLECTION];
173		/** @var Relations $relationCollection */
174	45	$relationCollection = Kernel::create(Relations::class, [$relationData, $this]);
175	45	$this->setRelations($relationCollection, true);
176
177		// Reset the object state
178	45	$this->resetState();
179	45	}
180
181		/**
182		* Return whether this object already has a draft revision
183		*
184		* @return bool Whether this object has a draft revision
185		*/
186	45	protected function hasDraft()
187		{
188		// Create the object draft resource locator
189	45	$draftLocator = $this->locator->setRevision(Revision::current(true));
190
191		// Use the object manager to look for a draft resource
192		/** @var ManagerInterface $objectManager */
193	45	$objectManager = Kernel::create(Service::class)->getObjectManager();
194	45	return $objectManager->objectResourceExists($draftLocator);
195		}
196
197		/**
198		* Update the object locator
199		*/
200	45	protected function updateLocator()
201		{
202	45	$revision = $this->getRevision();
203	45	$this->locator = $this->locator->setRevision(
204	45	!$revision->isDraft() && ($this->getCurrentRevision()->getRevision() == $revision->getRevision())
205	34	? Revision::current($revision->isDraft())
206	45	: $revision
207	45	)->setHidden($this->isDeleted());
208	45	}
209
210		/**
211		* Return this object's current revision
212		*
213		* @return Revision Current revision
214		*/
215	41	protected function getCurrentRevision()
216		{
217	41	if ($this->latestRevision->isDraft() && ($this->latestRevision->getRevision() > 1)) {
218	1	return Kernel::create(Revision::class, [$this->latestRevision->getRevision() - 1, false]);
219		}
220	41	return $this->latestRevision;
221		}
222
223		/**
224		* Use a specific object revision
225		*
226		* @param Revision $revision Revision to be used
227		* @return ObjectInterface Object
228		* @throws OutOfBoundsException If a revision beyond the latest one is requested
229		*/
230	40	public function useRevision(Revision $revision)
231		{
232		// If a revision beyond the latest one is requested
233	40	if (!$revision->isCurrent() && ($revision->getRevision() > $this->latestRevision->getRevision())) {
234	1	throw new OutOfBoundsException(
235	1	sprintf('Invalid object revision "%s"', $revision->getRevision()),
236	1	OutOfBoundsException::INVALID_OBJECT_REVISION
237		);
238		}
239
240		// Determine whether the current revision was requested
241	40	$currentRevision = $this->getCurrentRevision();
242	40	$isCurrentRevision = $revision->isCurrent() \|\| $currentRevision->equals($revision);
243	40	if ($isCurrentRevision) {
244	40	$revision = $currentRevision;
245		}
246
247		// If the requested revision is not already used
248	40	if (!$this->getRevision()->equals($revision)) {
249
250		/** @var ManagerInterface $objectManager */
251	1	$objectManager = Kernel::create(Service::class)->getObjectManager();
252		/** @var Revision $newRevision */
253	1	$newRevision = $isCurrentRevision ? Revision::current() : $revision;
254		/** @var RepositoryLocator $newRevisionLocator */
255	1	$newRevisionLocator = $this->locator->setRevision($newRevision);
256
257		// Instantiate the requested revision resource
258	1	$revisionResource = $objectManager->loadObjectResource($newRevisionLocator, SelectorInterface::ALL);
259
260		// Load the revision resource data
261	1	$this->loadRevisionData($revisionResource->getPayload(), $revisionResource->getPropertyData());
262
263		// Update the object locator
264	1	$this->updateLocator();
265		}
266
267	40	return $this;
268		}
269
270		/**
271		* Return the object repository locator
272		*
273		* @return RepositoryLocatorInterface Object repository locator
274		*/
275	47	public function getRepositoryLocator()
276		{
277	47	return $this->locator;
278		}
279
280		/**
281		* Return the object property data
282		*
283		* @param bool $serialize Serialize property objects
284		* @return array Object property data
285		*/
286	10	public function getPropertyData($serialize = true)
287		{
288	10	$propertyData = array_filter([
289	10	SystemProperties::COLLECTION => $this->systemProperties->toArray($serialize),
290	10	MetaProperties::COLLECTION => $this->metaProperties->toArray($serialize),
291	10	AbstractDomainProperties::COLLECTION => $this->domainProperties->toArray($serialize),
292	10	ProcessingInstructions::COLLECTION => $this->processingInstructions->toArray($serialize),
293	10	Relations::COLLECTION => $this->relations->toArray($serialize),
294	10	], function (array $collection) {
295	10	return (boolean)count($collection);
296	10	});
297
298	10	return $propertyData;
299		}
300
301		/**
302		* Return the absolute object URL
303		*
304		* @return string
305		*/
306	5	public function getAbsoluteUrl()
307		{
308	5	return getenv('APPARAT_BASE_URL').rtrim($this->locator->getRepository()->getUrl(), '/').strval($this->locator);
309		}
310
311		/**
312		* Return the canonical object URL
313		*
314		* @return string
315		*/
316	1	public function getCanonicalUrl()
317		{
318	1	$canonicalLocator = $this->locator->setRevision(Revision::current());
319	1	$canonicalUrl = ltrim($this->locator->getRepository()->getUrl(), '/').strval($canonicalLocator);
320	1	return getenv('APPARAT_BASE_URL').$canonicalUrl;
321		}
322
323		/**
324		* Persist the current object revision
325		*
326		* @return ObjectInterface Object
327		*/
328	5	public function persist()
329		{
330		// If this is not the latest revision
331	5	if ($this->getRevision()->getRevision() !== $this->latestRevision->getRevision()) {
332	1	throw new RuntimeException(
333		sprintf(
334	1	'Cannot persist revision %s/%s',
335	1	$this->getRevision()->getRevision(),
336	1	$this->latestRevision->getRevision()
337		),
338	1	RuntimeException::CANNOT_PERSIST_EARLIER_REVISION
339		);
340		}
341
342		// Update the object repository
343	5	$this->locator->getRepository()->updateObject($this);
344
345		// Reset to a clean state
346	3	$this->resetState();
347	3	$this->latestRevision = $this->getRevision();
348	3	$this->updateLocator();
349
350		// Post persistence hook
351	3	$this->postPersist();
352
353	2	return $this;
354		}
355
356		/**
357		* Post persistence hook
358		*
359		* @return void
360		*/
361	3	protected function postPersist()
362		{
363	3	}
364
365		/**
366		* Publish the current object revision
367		*
368		* @return ObjectInterface Object
369		*/
370	2	public function publish()
371		{
372		// If this is an unpublished draft
373	2	if ($this->isDraft() & !$this->hasBeenPublished()) {
374	2	$this->setPublishedState();
375	2	$this->latestRevision = $this->latestRevision->setDraft(false);
376	2	$this->updateLocator();
377		}
378
379	2	return $this;
380		}
381
382		/**
383		* Delete the object and all its revisions
384		*
385		* @return ObjectInterface Object
386		*/
387	3	public function delete()
388		{
389		// If this object is not already deleted
390	3	if (!$this->isDeleted() && !$this->hasBeenDeleted()) {
391	3	$this->setDeletedState();
392	3	$this->updateLocator();
393		}
394
395	3	return $this;
396		}
397
398		/**
399		* Undelete the object and all its revisions
400		*
401		* @return ObjectInterface Object
402		*/
403	2	public function undelete()
404		{
405		// If this object is already deleted
406	2	if ($this->isDeleted() && !$this->hasBeenUndeleted()) {
407	2	$this->setUndeletedState();
408	2	$this->updateLocator();
409		}
410
411	2	return $this;
412		}
413
414		/**
415		* Convert this object revision into a draft
416		*/
417	5	protected function convertToDraft()
418		{
419		// Assume the latest revision as draft revision
420	5	$draftRevision = $this->latestRevision;
421
422		// If it equals the current revision: Spawn a draft
423	5	if ($draftRevision->equals($this->getCurrentRevision())) {
424	5	$draftRevision = $this->latestRevision = $draftRevision->increment()->setDraft(true);
425		}
426
427		// Set the system properties to draft mode
428	5	$this->setSystemProperties($this->systemProperties->createDraft($draftRevision), true);
429
430		// Update the object locator
431	5	$this->updateLocator();
432	5	}
433		}
434

apparat / object

Push — master ( 108e84...f077fb )

AbstractObject::updateLocator() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like