CascadedSoftDeletes::instanceUsesSoftDelete() - Code Metrics - razisayyed/laravel-cascaded-soft-deletes - Measure and Improve Code Quality continuously with Scrutinizer

CascadedSoftDeletes::instanceUsesSoftDelete() A
last analyzed 2024-02-27 18:10 UTC

↳ Parent: CascadedSoftDeletes

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
eloc	5
c	2
b	0
f	0
dl	0
loc	11
rs	10
cc	2
nc	2
nop	0

<?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') ?
            Str::startsWith(app()->/** @scrutinizer ignore-call */ version(), '7') ?
                CascadeSoftDeletes::dispatchNow($this, 'delete', null) :
                /** @scrutinizer ignore-deprecated */ CascadeSoftDeletes::dispatchNow($this, 'delete', null) :
                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) :
                /** @scrutinizer ignore-deprecated */ CascadeSoftDeletes::dispatchNow($this, 'restore', static::$instanceDeletedAt) :
                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'))
                    ->where($this->/** @scrutinizer ignore-call */ getDeletedAtColumn(), '>=', $instanceDeletedAt->format('Y-m-d H:i:s.u'))
                    ->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([]);
            $softDeletes = collect(/** @scrutinizer ignore-type */ []);
        }

        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);
        });
    }
}


razisayyed / laravel-cascaded-soft-deletes

CascadedSoftDeletes::instanceUsesSoftDelete() A last analyzed 2024-02-27 18:10 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

CascadedSoftDeletes::instanceUsesSoftDelete() A
last analyzed 2024-02-27 18:10 UTC