LaravelFlare\Flare\Admin\Models\Traits\ModelSoftDeleting

Complexity

Total Complexity

12

Size/Duplication

Total Lines	159
Duplicated Lines	8.81 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	find()	0	4	1
A	findWithTrashed()	0	6	1
A	findOnlyTrashed()	0	6	1
A	beforeDelete()	0	3	1
A	delete()	14	14	1
A	doDelete()	0	12	2
A	afterDelete()	0	3	1
A	beforeRestore()	0	3	1
A	restore()	0	14	1
A	doRestore()	0	6	1
A	afterRestore()	0	3	1

<?php

namespace LaravelFlare\Flare\Admin\Models\Traits;

use LaravelFlare\Flare\Events\ModelDelete;
use LaravelFlare\Flare\Events\AfterDelete;
use LaravelFlare\Flare\Events\BeforeDelete;
use LaravelFlare\Flare\Events\ModelRestore;
use LaravelFlare\Flare\Events\AfterRestore;
use LaravelFlare\Flare\Events\BeforeRestore;
use LaravelFlare\Flare\Events\ModelSoftDelete;

trait ModelSoftDeleting
{
    use ModelDeleting;

    /**
     * Overrides the ModelQuerying provided method 
     * with one which searches withTrashed scope.
     * 
     * @param int $modelitemId
     * 
     * @return
     */
    public function find($modelitemId)
    {
        return $this->findWithTrashed($modelitemId);
    }

    /**
     * Finds model and includes withTrashed() scope in query.
     *
     * @param int $modelitemId
     * 
     * @return
     */
    public function findWithTrashed($modelitemId)
    {
        $this->model = $this->model->withTrashed()->findOrFail($modelitemId);

        return $this->model;
    }

    /**
     * Finds model and includes onlyTrashed() scope in query.
     *
     * @param int $modelitemId
     * 
     * @return
     */
    public function findOnlyTrashed($modelitemId)
    {
        $this->model = $this->model->onlyTrashed()->findOrFail($modelitemId);

        return $this->model;
    }

    /**
     * Method fired before the Delete action is undertaken.
     * 
     * @return
     */
    protected function beforeDelete()
    {
    }

    /**
     * Delete Action.
     *
     * Fires off beforeDelete(), doDelete() and afterDelete()
     * 
     * @param int $modelitemId
     * 
     * @return
     */
    public function delete($modelitemId)
    {
        event(new BeforeDelete($this));

        $this->findWithTrashed($modelitemId);

        $this->beforeDelete();

        $this->doDelete();

        $this->afterDelete();

        event(new AfterDelete($this));
    }

    /**
     * The actual delete action.
     * 
     * @return
     */
    private function doDelete()
    {
        if (!$this->model->trashed()) {
            $this->model->delete();
            event(new ModelSoftDelete($this));

            return;
        }

        $this->model->forceDelete();
        event(new ModelDelete($this));
    }

    /**
     * Method fired after the Delete action is complete.
     * 
     * @return
     */
    protected function afterDelete()
    {
    }

    /**
     * Method fired before the Restore action is undertaken.
     * 
     * @return
     */
    protected function beforeRestore()
    {
    }

    /**
     * Restore Action.
     *
     * Fires off beforeRestore(), doRestore() and afterRestore()
     * 
     * @param int $modelitemId
     * 
     * @return
     */
    public function restore($modelitemId)
    {
        event(new BeforeRestore($this));

        $this->findOnlyTrashed($modelitemId);

        $this->beforeRestore();

        $this->doRestore();

        $this->afterRestore();

        event(new AfterRestore($this));
    }

    /**
     * The actual restore action.
     * 
     * @return
     */
    private function doRestore()
    {
        $this->model->restore();

        event(new ModelRestore($this));
    }

    /**
     * Method fired after the Restore action is complete.
     * 
     * @return
     */
    protected function afterRestore()
    {
    }
}