StingerSoft\EntitySearchBundle\Services\DoctrineListener

Complexity

Total Complexity

24

Size/Duplication

Total Lines	186
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getSubscribedEvents()	0	8	1
A	getEventDispatcher()	0	3	1
A	setEventDispatcher()	0	3	1
A	enableIndexing()	0	3	1
A	disableIndexing()	0	3	1
A	isIndexingEnabled()	0	3	1
A	postPersist()	0	6	2
A	postFlush()	0	6	2
A	preRemove()	0	6	2
A	postUpdate()	0	4	2
A	getEntityToDocumentMapper()	0	3	1
A	getSearchService()	0	3	1
A	updateEntity()	0	14	4
A	removeEntity()	0	10	3

<?php
declare(strict_types=1);

/*
 * This file is part of the Stinger Entity Search package.
 *
 * (c) Oliver Kotte <oliver.kotte@stinger-soft.net>
 * (c) Florian Meyer <florian.meyer@stinger-soft.net>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace StingerSoft\EntitySearchBundle\Services;

use Doctrine\Common\EventSubscriber;
use Doctrine\Common\Persistence\Event\LifecycleEventArgs;
use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\ORM\Event\PostFlushEventArgs;
use StingerSoft\EntitySearchBundle\Events\DocumentPreSaveEvent;
use StingerSoft\EntitySearchBundle\Model\SearchableAlias;
use StingerSoft\EntitySearchBundle\Services\Mapping\EntityToDocumentMapperInterface;
use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;

class DoctrineListener implements EventSubscriber {

	/**
	 *
	 * @var EntityToDocumentMapperInterface
	 */
	protected $entityToDocumentMapper;

	/**
	 *
	 * @var SearchService
	 */
	protected $searchService;

	/**
	 * @var bool
	 */
	protected $needsFlush = false;

	/**
	 * @var bool
	 */
	protected $enableIndexing;

	/**
	 * @var EventDispatcherInterface|null
	 */
	protected $eventDispatcher;

	/**
	 * DoctrineListener constructor.
	 * @param EntityToDocumentMapperInterface $entityToDocumentMapper
	 * @param SearchService $searchService
	 * @param bool $enableIndexing
	 */
	public function __construct(EntityToDocumentMapperInterface $entityToDocumentMapper, SearchService $searchService, $enableIndexing = false) {
		$this->entityToDocumentMapper = $entityToDocumentMapper;
		$this->searchService = $searchService;
		$this->enableIndexing = $enableIndexing;
	}

	/**
	 * @return array|string[]
	 */
	public function getSubscribedEvents(): array {
		return array(
			'postPersist',
			'postUpdate',
			'preRemove',
			'postFlush'
		);
	}

	/**
	 * @return EventDispatcherInterface|null
	 */
	public function getEventDispatcher(): ?EventDispatcherInterface {
		return $this->eventDispatcher;
	}

	/**
	 * @param EventDispatcherInterface|null $eventDispatcher
	 * @required
	 */
	public function setEventDispatcher(EventDispatcherInterface $eventDispatcher = null): void {
		$this->eventDispatcher = $eventDispatcher;
	}


	/**
	 *
	 */
	public function enableIndexing(): void {
		$this->enableIndexing = true;
	}

	/**
	 *
	 */
	public function disableIndexing(): void {
		$this->enableIndexing = false;
	}

	/**
	 * @return bool
	 */
	public function isIndexingEnabled(): bool {
		return $this->enableIndexing;
	}

	/**
	 * Index the entity after it is persisted for the first time
	 *
	 * @param LifecycleEventArgs $args
	 */
	public function postPersist(LifecycleEventArgs $args): void {
		if(!$this->enableIndexing) {
			return;
		}
		$this->updateEntity($args->getObject(), $args->getObjectManager());

$args->getObjectManager() of type object<Doctrine\Persistence\ObjectManager> is not a sub-type of object<Doctrine\Common\Persistence\ObjectManager>. It seems like you assume a child interface of the interface Doctrine\Persistence\ObjectManager to be always present.

	}

	/**
	 * @param PostFlushEventArgs $eventArgs
	 * @throws \Doctrine\ORM\ORMException
	 * @throws \Doctrine\ORM\OptimisticLockException
	 */
	public function postFlush(PostFlushEventArgs $eventArgs): void {
		if($this->needsFlush) {
			$this->needsFlush = false;
			$eventArgs->getEntityManager()->flush();
		}
	}

	/**
	 * Removes the entity from the index when it marked for deletion
	 *
	 * @param LifecycleEventArgs $args
	 */
	public function preRemove(LifecycleEventArgs $args): void {
		if(!$this->enableIndexing) {
			return;
		}
		$this->removeEntity($args->getObject(), $args->getObjectManager());

$args->getObjectManager() of type object<Doctrine\Persistence\ObjectManager> is not a sub-type of object<Doctrine\Common\Persistence\ObjectManager>. It seems like you assume a child interface of the interface Doctrine\Persistence\ObjectManager to be always present.

	}

	/**
	 * Updates the entity in the index after it is updated
	 *
	 * @param LifecycleEventArgs $args
	 */
	public function postUpdate(LifecycleEventArgs $args): void {
		if(!$this->enableIndexing) return;
		$this->updateEntity($args->getObject(), $args->getObjectManager());

$args->getObjectManager() of type object<Doctrine\Persistence\ObjectManager> is not a sub-type of object<Doctrine\Common\Persistence\ObjectManager>. It seems like you assume a child interface of the interface Doctrine\Persistence\ObjectManager to be always present.

	}

	/**
	 *
	 * @return EntityToDocumentMapperInterface
	 */
	protected function getEntityToDocumentMapper(): EntityToDocumentMapperInterface {
		return $this->entityToDocumentMapper;
	}

	/**
	 *
	 * @return SearchService
	 */
	protected function getSearchService(): SearchService {
		return $this->searchService;
	}

	/**
	 *
	 * @param object $entity
	 */
	protected function updateEntity(object $entity, ObjectManager $manager): void {
		if($entity instanceof SearchableAlias) {
			$entity = $entity->getEntityToIndex();
		}
		$document = $this->getEntityToDocumentMapper()->createDocument($manager, $entity);
		if($document !== null) {
			if($this->getEventDispatcher()) {
				$event = new DocumentPreSaveEvent($document);
				$this->getEventDispatcher()->dispatch($event, DocumentPreSaveEvent::NAME);
			}
			$this->getSearchService()->saveDocument($document);
			$this->needsFlush = true;
		}
	}

	/**
	 *
	 * @param object $entity
	 */
	protected function removeEntity(object $entity, ObjectManager $manager): void {
		if($entity instanceof SearchableAlias) {
			$entity = $entity->getEntityToIndex();
		}
		$document = $this->getEntityToDocumentMapper()->createDocument($manager, $entity);
		if($document !== null) {
			$this->getSearchService()->removeDocument($document);
			$this->needsFlush = true;
		}
	}
}