Longman\Platfourm\Database\Eloquent\Traits\SoftDeletes

Complexity

Total Complexity

19

Size/Duplication

Total Lines	199
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

0%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	bootSoftDeletes()	0	4	1
A	forceDelete()	0	10	1
A	performDeleteOnModel()	0	8	2
A	runSoftDelete()	0	18	2
A	restore()	0	23	2
A	trashed()	0	4	1
A	withTrashed()	0	4	1
A	onlyTrashed()	0	8	1
A	restoring()	0	4	1
A	restored()	0	4	1
A	getDeletedAtColumn()	0	4	2
A	getDeletedByColumn()	0	4	2
A	getQualifiedDeletedAtColumn()	0	4	1
A	getQualifiedDeletedByColumn()	0	4	1

<?php
/*
 * This file is part of the Laravel Platfourm package.
 *
 * (c) Avtandil Kikabidze aka LONGMAN <akalongman@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Longman\Platfourm\Database\Eloquent\Traits;

use Longman\Platfourm\Contracts\Auth\AuthUserService;

trait SoftDeletes
{
    /**
     * Indicates if the model is currently force deleting.
     *
     * @var bool
     */
    protected $forceDeleting = false;

    /**
     * Boot the soft deleting trait for a model.
     *
     * @return void
     */
    public static function bootSoftDeletes()
    {
        static::addGlobalScope(new SoftDeletingScope);
    }

    /**
     * Force a hard delete on a soft deleted model.
     *
     * @return bool|null
     */
    public function forceDelete()
    {
        $this->forceDeleting = true;

        $deleted = $this->delete();

The method delete() does not exist on Longman\Platfourm\Database\Eloquent\Traits\SoftDeletes. Did you maybe mean bootSoftDeletes()?

        $this->forceDeleting = false;

        return $deleted;
    }

    /**
     * Perform the actual delete query on this model instance.
     *
     * @return mixed
     */
    protected function performDeleteOnModel()
    {
        if ($this->forceDeleting) {
            return $this->newQueryWithoutScopes()->where($this->getKeyName(), $this->getKey())->forceDelete();

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

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

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

        }

        return $this->runSoftDelete();
    }

    /**
     * Perform the actual delete query on this model instance.
     *
     * @return void
     */
    protected function runSoftDelete()
    {
        $query = $this->newQueryWithoutScopes()->where($this->getKeyName(), $this->getKey());

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

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

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

        $this->{$this->getDeletedAtColumn()} = $time = $this->freshTimestamp();

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

        $update = [
            $this->getDeletedAtColumn() => $this->fromDateTime($time),

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

        ];

        $userService = app()->make(AuthUserService::class);
        if ($userService->check()) {
            $this->{$this->getDeletedByColumn()} = $userService->user()->id;
            $update[$this->getDeletedByColumn()] = $userService->user()->id;
        }

        $query->update($update);
    }

    /**
     * Restore a soft-deleted model instance.
     *
     * @return bool|null
     */
    public function restore()
    {
        // If the restoring event does not return false, we will proceed with this
        // restore operation. Otherwise, we bail out so the developer will stop
        // the restore totally. We will clear the deleted timestamp and save.
        if ($this->fireModelEvent('restoring') === false) {

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

            return false;
        }

        $this->{$this->getDeletedAtColumn()} = null;
        $this->{$this->getDeletedByColumn()} = null;

        // Once we have saved the model, we will fire the "restored" event so this
        // developer will do anything they need to after a restore operation is
        // totally finished. Then we will return the result of the save call.
        $this->exists = true;

The property exists does not exist. Did you maybe forget to declare it?

        $result = $this->save();

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

        $this->fireModelEvent('restored', false);

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

        return $result;
    }

    /**
     * Determine if the model instance has been soft-deleted.
     *
     * @return bool
     */
    public function trashed()
    {
        return !is_null($this->{$this->getDeletedAtColumn()});
    }

    /**
     * Get a new query builder that includes soft deletes.
     *
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public static function withTrashed()
    {
        return (new static)->newQueryWithoutScope(new SoftDeletingScope);

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

    }

    /**
     * Get a new query builder that only includes soft deletes.
     *
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public static function onlyTrashed()
    {
        $instance = new static;

        $column = $instance->getQualifiedDeletedAtColumn();

        return $instance->newQueryWithoutScope(new SoftDeletingScope)->whereNotNull($column);

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

    }

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

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

    /**
     * Get the name of the "deleted at" column.
     *
     * @return string
     */
    public function getDeletedAtColumn()
    {
        return defined('static::DELETED_AT') ? static::DELETED_AT : 'deleted_at';
    }

    /**
     * Get the name of the "deleted by" column.
     *
     * @return string
     */
    public function getDeletedByColumn()
    {
        return defined('static::DELETED_BY') ? static::DELETED_BY : 'deleted_by';
    }

    /**
     * Get the fully qualified "deleted at" column.
     *
     * @return string
     */
    public function getQualifiedDeletedAtColumn()
    {
        return $this->getTable() . '.' . $this->getDeletedAtColumn();

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

    }

    /**
     * Get the fully qualified "deleted by" column.
     *
     * @return string
     */
    public function getQualifiedDeletedByColumn()
    {
        return $this->getTable() . '.' . $this->getDeletedByColumn();

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

    }

}