SoftDeleteTrait::findWithDeleted() - Code Metrics - funayaki/cakephp3-soft-delete - Measure and Improve Code Quality continuously with Scrutinizer

SoftDeleteTrait::findWithDeleted() A
last analyzed 2019-01-11 04:09 UTC

↳ Parent: SoftDeleteTrait
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	1
dl	0
loc	3
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0
<?php
namespace SoftDelete\Model\Table;

use Cake\ORM\RulesChecker;
use Cake\Datasource\EntityInterface;
use Cake\Utility\Hash;
use SoftDelete\Error\MissingColumnException;
use SoftDelete\ORM\Query;

trait SoftDeleteTrait
{

    /**
     * @var boolean
     */
    protected $_findWithDeleted;

    /**
     * Get the configured deletion field
     *
     * @return string
     * @throws \SoftDelete\Error\MissingFieldException
     */
    public function ensureSoftDeleteFieldExists()
    {
        $callable = [$this, 'getSoftDeleteField'];
        if (!is_callable($callable)) {
            throw new \BadMethodCallException();
        }

        $field = call_user_func($callable);

        if ($this->getSchema()->getColumn($field) === null) {
        if ($this->/** @scrutinizer ignore-call */ getSchema()->getColumn($field) === null) {
            throw new MissingColumnException(
                __('Configured field `{0}` is missing from the table `{1}`.',
                    $field,
                    $this->getAlias()
                           getAlias()
                )
            );
        }

        return $field;
    }

    public function query()
    {
        return new Query($this->getConnection(), $this);
        return new Query($this->getConnection(), /** @scrutinizer ignore-type */ $this);
    }

    /**
     * Perform the delete operation.
     *
     * Will soft delete the entity provided. Will remove rows from any
     * dependent associations, and clear out join tables for BelongsToMany associations.
     *
     * @param \Cake\DataSource\EntityInterface $entity The entity to soft delete.
     * @param \ArrayObject $options The options for the delete.
     * @throws \InvalidArgumentException if there are no primary key values of the
     * passed entity
     * @return bool success
     */
    protected function _processDelete($entity, $options)
    {
        if ($entity->isNew()) {
            return false;
        }

        $primaryKey = (array)$this->getPrimaryKey();
        $primaryKey = (array)$this->/** @scrutinizer ignore-call */ getPrimaryKey();
        if (!$entity->has($primaryKey)) {
            $msg = 'Deleting requires all primary key values.';
            throw new \InvalidArgumentException($msg);
        }

        if ($options['checkRules'] && !$this->checkRules($entity, RulesChecker::DELETE, $options)) {
        if ($options['checkRules'] && !$this->/** @scrutinizer ignore-call */ checkRules($entity, RulesChecker::DELETE, $options)) {
            return false;
        }

        $event = $this->dispatchEvent('Model.beforeDelete', [
        $event = $this->dispatchEvent('Model.beforeDelete', [
            'entity' => $entity,
            'options' => $options
        ]);

        if ($event->isStopped()) {
            return $event->result;
        }

        $this->_associations->cascadeDelete(
            $entity,
            ['_primary' => false] + $options->getArrayCopy()
        );

        $query = $this->query();
        $conditions = (array)$entity->extract($primaryKey);
        $statement = $query->update()
            ->set([$this->ensureSoftDeleteFieldExists() => $this->getSoftDeleteValue()])
            ->set([$this->ensureSoftDeleteFieldExists() => $this->/** @scrutinizer ignore-call */ getSoftDeleteValue()])
            ->where($conditions)
            ->execute();

        $success = $statement->rowCount() > 0;
        if (!$success) {
            return $success;
        }

        $this->dispatchEvent('Model.afterDelete', [
            'entity' => $entity,
            'options' => $options
        ]);

        return $success;
    }

    /**
     * Soft deletes all records matching `$conditions`.
     * @return int number of affected rows.
     */
    public function deleteAll($conditions)
    {
        $query = $this->query()
            ->update()
            ->set([$this->ensureSoftDeleteFieldExists() => $this->getSoftDeleteValue()])
            ->where($conditions);
        $statement = $query->execute();
        $statement->closeCursor();
        return $statement->rowCount();
    }

    /**
     * Hard deletes the given $entity.
     * @return bool true in case of success, false otherwise.
     */
    public function hardDelete(EntityInterface $entity)
    {
        if (!$this->delete($entity)) {
        if (!$this->/** @scrutinizer ignore-call */ delete($entity)) {
            return false;
        }
        $primaryKey = (array)$this->getPrimaryKey();
        $query = $this->query();
        $conditions = (array)$entity->extract($primaryKey);
        $statement = $query->delete()
            ->where($conditions)
            ->execute();

        $success = $statement->rowCount() > 0;
        if (!$success) {
            return $success;
        }

        return $success;
    }

    /**
     * Hard deletes all records that were soft deleted before a given date.
     * @param $conditions
     * @return int number of affected rows.
     */
    public function hardDeleteAll($conditions)
    {
        $conditions = Hash::merge($conditions, ['NOT' => [$this->getActiveExpression()]]);

        $query = $this->query()
            ->delete()
            ->where($conditions);
        $statement = $query->execute();
        $statement->closeCursor();
        return $statement->rowCount();
    }

    /**
     * Restore a soft deleted entity into an active state.
     * @param EntityInterface $entity Entity to be restored.
     * @return bool true in case of success, false otherwise.
     */
    public function restore(EntityInterface $entity)
    {
        $softDeleteField = $this->ensureSoftDeleteFieldExists();
        $entity->$softDeleteField = $this->getRestoreValue();
        $entity->$softDeleteField = $this->getRestoreValue();
        return $this->save($entity);
        return $this->/** @scrutinizer ignore-call */ save($entity);
    }

    /**
     * @param bool $enable
     */
    public function enableFindWithDeleted($enable = true)
    {
        $this->_findWithDeleted = (bool)$enable;
    }

    /**
     * @return bool
     */
    public function findWithDeleted()
    {
        return $this->_findWithDeleted;
    }

    /**
     * @return array|string
     */
    public function getActiveExpression()
    {
        $aliasedField = $this->aliasField($this->ensureSoftDeleteFieldExists());
        $aliasedField = $this->aliasField($this->ensureSoftDeleteFieldExists());
        $activeValue = $this->getRestoreValue();

        if ($activeValue === null) {
            return $aliasedField . ' IS NULL';
        }

        return [$aliasedField => $activeValue];
    }
}

funayaki / cakephp3-soft-delete

SoftDeleteTrait::findWithDeleted() A last analyzed 2019-01-11 04:09 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

SoftDeleteTrait::findWithDeleted() A
last analyzed 2019-01-11 04:09 UTC
