Nip\Records\EventManager\HasEvents

Complexity

Total Complexity

13

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Test Coverage

Coverage

36.84%

Importance

Changes	1
Bugs	0	Features	1

13 Methods

Rating	Name	Duplication	Size	Complexity
A	replicating()	0	3	1
A	registerModelEvent()	0	3	1
A	saved()	0	3	1
A	fireModelEvent()	0	4	1
A	deleting()	0	3	1
A	created()	0	3	1
A	updated()	0	3	1
A	updating()	0	3	1
A	deleted()	0	3	1
A	creating()	0	3	1
A	retrieved()	0	3	1
A	saving()	0	3	1
A	eventManager()	0	3	1

<?php

namespace Nip\Records\EventManager;

use Nip\Records\AbstractModels\Record;
use Nip\Records\EventManager\Events\Event;
use Nip\Records\EventManager\Events\Observe;

/**
 * Trait HasEvents
 * @package Nip\Records\Events
 */
trait HasEvents
{
    use HasObservables;

    /**
     * Register a retrieved model event with the dispatcher.
     *
     * @param \Closure|string $callback
     * @return void
     */
    public static function retrieved($callback)
    {
        static::registerModelEvent('retrieved', $callback);
    }

    /**
     * Register a saving model event with the dispatcher.
     *
     * @param \Closure|string $callback
     * @return void
     */
    public static function saving($callback)
    {
        static::registerModelEvent('saving', $callback);
    }

    /**
     * Register a saved model event with the dispatcher.
     *
     * @param \Closure|string $callback
     * @return void
     */
    public static function saved($callback)
    {
        static::registerModelEvent('saved', $callback);
    }

    /**
     * Register an updating model event with the dispatcher.
     *
     * @param \Closure|string $callback
     * @return void
     */
    public static function updating($callback)
    {
        static::registerModelEvent('updating', $callback);
    }

    /**
     * Register an updated model event with the dispatcher.
     *
     * @param \Closure|string $callback
     * @return void
     */
    public static function updated($callback)
    {
        static::registerModelEvent('updated', $callback);
    }

    /**
     * Register a creating model event with the dispatcher.
     *
     * @param \Closure|string $callback
     * @return void
     */
    public static function creating($callback)
    {
        static::registerModelEvent(Observe::CREATING, $callback);
    }

    /**
     * Register a created model event with the dispatcher.
     *
     * @param \Closure|string $callback
     * @return void
     */
    public static function created($callback)
    {
        static::registerModelEvent(Observe::CREATED, $callback);
    }

    /**
     * Register a replicating model event with the dispatcher.
     *
     * @param \Closure|string $callback
     * @return void
     */
    public static function replicating($callback)
    {
        static::registerModelEvent('replicating', $callback);
    }

    /**
     * Register a deleting model event with the dispatcher.
     *
     * @param \Closure|string $callback
     * @return void
     */
    public static function deleting($callback)
    {
        static::registerModelEvent('deleting', $callback);
    }

    /**
     * Register a deleted model event with the dispatcher.
     *
     * @param \Closure|string $callback
     * @return void
     */
    public static function deleted($callback)
    {
        static::registerModelEvent('deleted', $callback);
    }

    /**
     * @param $event
     * @param $callback
     */
    protected static function registerModelEvent($event, $callback)
    {
        static::eventManager()->registerModelEvent($event, static::class, $callback);

static::class of type string is incompatible with the type Nip\Records\AbstractModels\RecordManager|Nip\Records\EventManager\HasEvents expected by parameter $manager of Nip\Records\EventManager\EventManager::registerModelEvent().

    }

    /**
     * Fire the given event for the model.
     *
     * @param string $event
     * @param Record $record
     * @return mixed
     */
    protected function fireModelEvent($event, Record $record)
    {
        $event = Event::create($event, $this)->withRecord($record);
        return static::eventManager()->dispatch($event);
    }

    /**
     * @return EventManager
     */
    protected static function eventManager()
    {
        return EventManager::instance();
    }
}