BEdita\Chatlas\Event\ChatlasEventHandler

Complexity

Total Complexity

21

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	afterSaveAssociated()	0	31	8
A	afterDelete()	0	8	3
A	implementedEvents()	0	6	1
B	afterSave()	0	27	9

<?php
declare(strict_types=1);

/**
 * Chatlas BEdita plugin
 *
 * Copyright 2023 Atlas Srl
 */
namespace BEdita\Chatlas\Event;

use ArrayObject;
use BEdita\Chatlas\Index\CollectionHandler;
use BEdita\Core\Model\Entity\ObjectEntity;
use BEdita\Core\ORM\Association\RelatedTo;
use Cake\Datasource\EntityInterface;
use Cake\Event\Event;
use Cake\Event\EventInterface;
use Cake\Event\EventListenerInterface;
use Cake\ORM\Locator\LocatorAwareTrait;
use Cake\Utility\Hash;

/**
 * Event listener for chatlas collection related events.
 */
class ChatlasEventHandler implements EventListenerInterface
{
    use LocatorAwareTrait;

    /**
     * @inheritDoc
     */
    public function implementedEvents(): array
    {
        return [
            'Model.afterDelete' => 'afterDelete',
            'Model.afterSave' => 'afterSave',
            'Associated.afterSave' => 'afterSaveAssociated',
        ];
    }

    /**
     * After save listener:
     *  * create or update collections
     *  * add, update or remove documents from collections
     *
     * @param \Cake\Event\EventInterface $event The dispatched event.
     * @param \Cake\Datasource\EntityInterface $entity The Entity saved.
     * @param \ArrayObject $options The options
     * @return void
     */
    public function afterSave(EventInterface $event, EntityInterface $entity, ArrayObject $options): void
    {
        $type = (string)$entity->get('type');
        if (empty($type) || !$entity instanceof ObjectEntity || !empty($options['_skipAfterSave'])) {
            return;
        }
        $handler = new CollectionHandler();
        if ($type === 'collections') {
            if ($entity->isNew()) {
                $handler->createCollection($entity);

                return;
            }

            $handler->updateCollection($entity);
        }
        // Look if there is a `DocumentOf` relation
        if (!$entity->getTable()->hasAssociation('DocumentOf')) {
            return;
        }
        $entity->getTable()->loadInto($entity, ['DocumentOf']);
        $collections = $entity->get('document_of');
        if (empty($collections)) {
            return;
        }
        foreach ($collections as $collection) {
            $handler->updateDocument($collection, $entity);
        }
    }

    /**
     * Handle 'Associated.afterSave'
     *
     * @param \Cake\Event\Event $event Dispatched event.
     * @return void
     */
    public function afterSaveAssociated(Event $event): void
    {
        $data = $event->getData();
        $association = Hash::get($data, 'association');
        if (empty($association) || !$association instanceof RelatedTo) {
            return;
        }
        $name = $association->getName();
        if (!in_array($name, ['DocumentOf', 'HasDocuments'])) {
            return;
        }
        $entity = Hash::get($data, 'entity');
        if (!$entity instanceof ObjectEntity) {
            return;
        }
        $handler = new CollectionHandler();
        $action = Hash::get($data, 'action');
        $related = (array)Hash::get($data, 'relatedEntities');
        foreach ($related as $item) {
            if ($name === 'DocumentOf') {
                $collection = $item;
                $document = $entity;
            } else {
                $collection = $entity;
                $document = $item;
            }

            if ($action === 'remove') {
                $handler->removeDocument($collection, $document);
            } else {
                $handler->updateDocument($collection, $document, true);
            }
        }
    }

    /**
     * After delete listener: remove collections
     *
     * @param \Cake\Event\EventInterface $event The dispatched event.
     * @param \Cake\Datasource\EntityInterface $entity The Entity saved.
     * @return void
     */
    public function afterDelete(EventInterface $event, EntityInterface $entity): void
    {
        $type = (string)$entity->get('type');
        if (!$entity instanceof ObjectEntity || $type !== 'collections') {
            return;
        }
        $handler = new CollectionHandler();
        $handler->removeCollection($entity);
    }
}