Signifly\PivotEvents\HasPivotEvents

Complexity

Total Complexity

19

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Importance

Changes	4
Bugs	0	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	setPivotChanges()	0	4	1
A	getPivotChanges()	0	5	2
A	pivotDetached()	0	3	1
A	firePivotDetachedEvent()	0	3	1
A	pivotAttached()	0	3	1
A	pivotUpdated()	0	3	1
A	newBelongsToMany()	0	11	1
A	pivotAttaching()	0	3	1
A	getPivotChangeIds()	0	3	1
A	firePivotDetachingEvent()	0	3	1
A	resetPivotChanges()	0	3	1
A	pivotUpdating()	0	3	1
A	getObservableEvents()	0	8	1
A	firePivotUpdatedEvent()	0	3	1
A	firePivotAttachingEvent()	0	3	1
A	firePivotAttachedEvent()	0	3	1
A	firePivotUpdatingEvent()	0	3	1
A	pivotDetaching()	0	3	1

<?php

namespace Signifly\PivotEvents;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Collection;

trait HasPivotEvents
{
    protected $pivotChanges = [];

    public function setPivotChanges(string $type, string $relation, array $ids = []): void
    {
        collect($ids)->each(function ($attributes, $id) use ($type, $relation) {

$ids of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            data_set($this->pivotChanges, "{$type}.{$relation}.{$id}", $attributes);
        });
    }

    public function getPivotChanges($type = null): Collection
    {
        return $type
            ? collect(data_get($this->pivotChanges, $type))
            : collect($this->pivotChanges);

$this->pivotChanges of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

    }

    public function getPivotChangeIds($type, $relation): Collection
    {
        return collect($this->getPivotChanges("{$type}.{$relation}"))->keys();
    }

    public function resetPivotChanges(): void
    {
        $this->pivotChanges = [];
    }

    public static function pivotAttaching($callback)
    {
        static::registerModelEvent('pivotAttaching', $callback);
    }

    public static function pivotAttached($callback)
    {
        static::registerModelEvent('pivotAttached', $callback);
    }

    public static function pivotDetaching($callback)
    {
        static::registerModelEvent('pivotDetaching', $callback);
    }

    public static function pivotDetached($callback)
    {
        static::registerModelEvent('pivotDetached', $callback);
    }

    public static function pivotUpdating($callback)
    {
        static::registerModelEvent('pivotUpdating', $callback);
    }

    public static function pivotUpdated($callback)
    {
        static::registerModelEvent('pivotUpdated', $callback);
    }

    public function firePivotAttachingEvent($halt = true)
    {
        return $this->fireModelEvent('pivotAttaching', $halt);

It seems like fireModelEvent() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    public function firePivotAttachedEvent($halt = false)
    {
        return $this->fireModelEvent('pivotAttached', $halt);
    }

    public function firePivotDetachingEvent($halt = true)
    {
        return $this->fireModelEvent('pivotDetaching', $halt);
    }

    public function firePivotDetachedEvent($halt = false)
    {
        return $this->fireModelEvent('pivotDetached', $halt);
    }

    public function firePivotUpdatingEvent($halt = true)
    {
        return $this->fireModelEvent('pivotUpdating', $halt);
    }

    public function firePivotUpdatedEvent($halt = false)
    {
        return $this->fireModelEvent('pivotUpdated', $halt);
    }

    /**
     * Get the observable event names.
     *
     * @return array
     */
    public function getObservableEvents()
    {
        return array_merge(
            parent::getObservableEvents(),
            [
                'pivotAttaching', 'pivotAttached',
                'pivotDetaching', 'pivotDetached',
                'pivotUpdating', 'pivotUpdated',
            ]
        );
    }

    /**
     * Instantiate a new BelongsToMany relationship.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @param  \Illuminate\Database\Eloquent\Model  $parent
     * @param  string  $table
     * @param  string  $foreignPivotKey
     * @param  string  $relatedPivotKey
     * @param  string  $parentKey
     * @param  string  $relatedKey
     * @param  string  $relationName
     * @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
     */
    protected function newBelongsToMany(
        Builder $query,
        Model $parent,
        $table,
        $foreignPivotKey,
        $relatedPivotKey,
        $parentKey,
        $relatedKey,
        $relationName = null
    ) {
        return new BelongsToMany($query, $parent, $table, $foreignPivotKey, $relatedPivotKey, $parentKey, $relatedKey, $relationName);
    }
}