RaziAlsayyed\LaravelCascadedSoftDeletes\Traits\CascadedSoftDeletes

Complexity

Total Complexity

23

Size/Duplication

Total Lines	166
Duplicated Lines	0 %

Importance

Changes	4
Bugs	1	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	bootCascadedSoftDeletes()	0	13	2
A	isHardDeleting()	0	3	2
A	deleteCascadedSoftDeletes()	0	13	4
A	relationUsesSoftDelete()	0	14	2
A	restoreCascadedSoftDeleted()	0	9	3
B	cascadeSoftDeletes()	0	35	8
A	instanceUsesSoftDelete()	0	11	2

<?php

namespace RaziAlsayyed\LaravelCascadedSoftDeletes\Traits;

use Illuminate\Support\Str;
use RaziAlsayyed\LaravelCascadedSoftDeletes\Exceptions\LogicException;
use RaziAlsayyed\LaravelCascadedSoftDeletes\Exceptions\RuntimeException;
use RaziAlsayyed\LaravelCascadedSoftDeletes\Jobs\CascadeSoftDeletes;

trait CascadedSoftDeletes
{
    /**
     * Keeps track of Instance deleted_at time.
     *
     * @var \Carbon\Carbon
     */
    public static $instanceDeletedAt;

    /**
     * Sign on model events.
     */
    protected static function bootCascadedSoftDeletes()
    {
        static::deleted(function ($model) {
            $model->deleteCascadedSoftDeletes();
        });

        if (static::instanceUsesSoftDelete()) {
            static::restoring(function ($model) {
                static::$instanceDeletedAt = $model->{$model->getDeletedAtColumn()};
            });

            static::restored(function ($model) {
                $model->restoreCascadedSoftDeleted();
            });
        }
    }

    /**
     * Delete the cascaded relations.
     */
    protected function deleteCascadedSoftDeletes() : void
    {
        if ($this->isHardDeleting()) {
            return;
        }

        if (config('cascaded-soft-deletes.queue_cascades_by_default') === true) {
            CascadeSoftDeletes::dispatch($this, 'delete', null)->onQueue(config('cascaded-soft-deletes.queue_name'));
        } else {
            // @codeCoverageIgnoreStart
            Str::startsWith(app()->version(), '7') ?

The method version() does not exist on Illuminate\Container\Container. Are you sure you never get this type here, but always one of the subclasses?

                CascadeSoftDeletes::dispatchNow($this, 'delete', null) :

The function RaziAlsayyed\LaravelCascadedSoftDeletes\Jobs\CascadeSoftDeletes::dispatchNow() has been deprecated: Will be removed in a future Laravel version.

                CascadeSoftDeletes::dispatchSync($this, 'delete', null);
            // @codeCoverageIgnoreEnd
        }
    }

    /**
     * Restore the cascaded relations.
     */
    protected function restoreCascadedSoftDeleted() : void
    {
        if (config('cascaded-soft-deletes.queue_cascades_by_default') === true) {
            CascadeSoftDeletes::dispatch($this, 'restore', static::$instanceDeletedAt)->onQueue(config('cascaded-soft-deletes.queue_name'));
        } else {
            // @codeCoverageIgnoreStart
            Str::startsWith(app()->version(), '7') ?
                CascadeSoftDeletes::dispatchNow($this, 'restore', static::$instanceDeletedAt) :

The function RaziAlsayyed\LaravelCascadedSoftDeletes\Jobs\CascadeSoftDeletes::dispatchNow() has been deprecated: Will be removed in a future Laravel version.

                CascadeSoftDeletes::dispatchSync($this, 'restore', static::$instanceDeletedAt);
            // @codeCoverageIgnoreEnd
        }
        // CascadeSoftDeletes::dispatch($this, 'restore', static::$instanceDeletedAt);
    }

    /**
     * Delete/Restore Cascaded Relationships.
     *
     * @param $action
     */
    public function cascadeSoftDeletes(string $action, ?\Carbon\Carbon $instanceDeletedAt = null) : void
    {
        if (method_exists($this, 'getCascadedSoftDeletes')) {
            $relations = collect($this->getCascadedSoftDeletes());
        } elseif (property_exists($this, 'cascadedSoftDeletes')) {
            $relations = collect($this->cascadedSoftDeletes);
        } else {
            throw new RuntimeException('neither getCascadedSoftDeletes function or cascaded_soft_deletes property exists!');
        }

        $relations->each(function ($item, $key) use ($action, $instanceDeletedAt) {
            $relation = $key;
            if (is_numeric($key)) {
                $relation = $item;
            }

            if (!is_callable($item) && !$this->relationUsesSoftDelete($relation)) {
                throw new LogicException('relationship ' . $relation . ' does not use SoftDeletes trait.');
            }

            if (is_callable($item)) {
                $query = $item();
            } else {
                $query = $this->{$relation}();
            }

            if ($action == 'delete') {
                $query->get()->each->delete();
            } else {
                $query
                    ->onlyTrashed()
                    ->where($this->getDeletedAtColumn(), '>=', $instanceDeletedAt->format('Y-m-d H:i:s.u'))

The method format() does not exist on null.

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

                    ->get()
                    ->each
                    ->restore();
            }

            // else {
            //     $query = $query
            //         ->withTrashed()
            //         ->where($query->qualifyColumn($this->getDeletedAtColumn()), '>=', $instanceDeletedAt);

            //     dd($query->toSql(), $query->getBindings(), $query->pluck('deleted_at'));

            // }
        });
    }

    /**
     * Get whether user is intended to delete the model from database entirely.
     *
     * @return bool
     */
    protected function isHardDeleting() : bool
    {
        return !$this->instanceUsesSoftDelete() || $this->forceDeleting;
    }

    /**
     * Check if the instance uses SoftDeletes trait.
     *
     * @return bool
     */
    protected static function instanceUsesSoftDelete() : bool
    {
        static $softDelete;

        if (is_null($softDelete)) {
            $instance = new static;

            return $softDelete = method_exists($instance, 'bootSoftDeletes');
        }

        return $softDelete;
    }

    /**
     * Check if the relation uses SoftDeletes trait.
     *
     * @return bool
     */
    public static function relationUsesSoftDelete($relation) : bool
    {
        static $softDeletes;

        if (is_null($softDeletes)) {
            $softDeletes = collect([]);

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

        }

        return $softDeletes->get($relation, function () use ($relation, $softDeletes) {
            $instance = new static;
            $cls = $instance->{$relation}()->getRelated();
            $relationInstance = new $cls;

            return $softDeletes->put($relation, method_exists($relationInstance, 'bootSoftDeletes'))->get($relation);
        });
    }
}