Maslosoft\Mangan\Traits\Model\TrashableTrait

Complexity

Total Complexity

15

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	11

Test Coverage

Coverage

80.43%

Importance

Changes	9
Bugs	1	Features	1

2 Methods

Rating	Name	Duplication	Size	Complexity
C	trash()	0	46	9
B	restore()	0	45	6

<?php

/**
 * This software package is licensed under AGPL or Commercial license.
 *
 * @package maslosoft/mangan
 * @licence AGPL or Commercial
 * @copyright Copyright (c) Piotr Masełkowski <pmaselkowski@gmail.com>
 * @copyright Copyright (c) Maslosoft
 * @copyright Copyright (c) Others as mentioned in code
 * @link http://maslosoft.com/mangan/
 */

namespace Maslosoft\Mangan\Traits\Model;

use Exception;
use Maslosoft\Mangan\EntityManager;
use Maslosoft\Mangan\Events\Event;
use Maslosoft\Mangan\Events\ModelEvent;
use Maslosoft\Mangan\Events\RestoreEvent;
use Maslosoft\Mangan\Events\TrashEvent;
use Maslosoft\Mangan\Finder;
use Maslosoft\Mangan\Helpers\PkManager;
use Maslosoft\Mangan\Interfaces\TrashInterface;
use Maslosoft\Mangan\Meta\ManganMeta;
use Maslosoft\Mangan\Model\Trash;
use Maslosoft\Mangan\ScenarioManager;
use Maslosoft\Mangan\Validator;

/**
 * Uswe this trait to make model trashable
 *
 * @author Piotr
 */
trait TrashableTrait
{

	/**
	 * Move to trash. Validation will be performed
	 * before trashing with `trash` (TrashInterface::ScenarioTrash) scenario.
	 *
	 *
	 * @see TrashInterface::ScenarioTrash
	 * @param boolean $runValidation whether to perform validation before saving the record.
	 * If the validation fails, the record will not be saved to database.
	 *
	 * @return boolean
	 * @Ignored
	 */
	public function trash($runValidation = true)
	{
		ScenarioManager::setScenario($this, TrashInterface::ScenarioTrash);
		$validator = new Validator($this);
		if (!$runValidation || $validator->validate())
		{
			$eventBefore = new TrashEvent($this);
			if (Event::hasHandler($this, TrashInterface::EventBeforeTrash))
			{
				if (!Event::valid($this, TrashInterface::EventBeforeTrash, $eventBefore))
				{
					return false;
				}
			}
			$meta = ManganMeta::create($this);

			$trash = $eventBefore->getTrash();
			if (empty($trash))
			{
				$trash = new Trash();
			}
			$trash->name = (string) $this;

Accessing name on the interface Maslosoft\Mangan\Interfaces\TrashInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			$trash->data = $this;

Accessing data on the interface Maslosoft\Mangan\Interfaces\TrashInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			$trash->type = isset($meta->type()->label) ? $meta->type()->label : get_class($this);

Accessing type on the interface Maslosoft\Mangan\Interfaces\TrashInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

			if (!$trash->save())
			{
				return false;
			}

			$eventAfter = new TrashEvent($this);
			$eventAfter->setTrash($trash);

			if (!Event::valid($this, TrashInterface::EventAfterTrash, $eventAfter))
			{
				return false;
			}

			// Use deleteOne, to avoid beforeDelete event,
			// which should be raised only when really removing document:
			// when emtying trash

			$em = new EntityManager($this);
			return $em->deleteOne(PkManager::prepareFromModel($this));
		}
		return false;
	}

	/**
	 * Restore trashed item
	 * @return boolean
	 * @throws Exception
	 * @Ignored
	 */
	public function restore()
	{
		if (!$this instanceof TrashInterface)
		{
			// When trying to restore normal document instead of trash item
			throw new Exception(sprintf('Restore can be performed only on `%s` instance', TrashInterface::class));
		}
		$em = new EntityManager($this->data);

Accessing data on the interface Maslosoft\Mangan\Interfaces\TrashInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

		// Set scenario to `restore` for model, which is just about to be restored
		ScenarioManager::setScenario($this->data, TrashInterface::ScenarioRestore);

Accessing data on the interface Maslosoft\Mangan\Interfaces\TrashInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

		if (!Event::valid($this->data, TrashInterface::EventBeforeRestore))

Accessing data on the interface Maslosoft\Mangan\Interfaces\TrashInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

		{
			return false;
		}

		$saved = $em->save();
		if (!$saved)
		{
			return false;
		}
		$finder = new Finder($this->data);

Accessing data on the interface Maslosoft\Mangan\Interfaces\TrashInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

		$model = $finder->find(PkManager::prepareFromModel($this->data));

Accessing data on the interface Maslosoft\Mangan\Interfaces\TrashInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

		if (!$model)
		{
			return false;
		}
		$eventAfter = new RestoreEvent();
		$eventAfter->setTrashed($this->data);

Accessing data on the interface Maslosoft\Mangan\Interfaces\TrashInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

		$eventAfter->setTrash($this);
		if (!Event::valid($model, TrashInterface::EventAfterRestore, $eventAfter))
		{
			return false;
		}

		$trashEm = new EntityManager($this);

$this is of type object<Maslosoft\Mangan\Interfaces\TrashInterface>, but the function expects a object<Maslosoft\Addendum\Interfaces\AnnotatedInterface>.

		$this->data = null;

Accessing data on the interface Maslosoft\Mangan\Interfaces\TrashInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

		// Use deleteOne, to avoid beforeDelete event,
		// which should be raised only when really removing document:
		// when emtying trash
		return $trashEm->deleteOne(PkManager::prepareFromModel($this));

$this is of type object<Maslosoft\Mangan\Interfaces\TrashInterface>, but the function expects a object<Maslosoft\Addendum\Interfaces\AnnotatedInterface>.

	}

}