funayaki / cakephp3-soft-delete

src/Model/Table/SoftDeleteTrait.php

<?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) {

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

            throw new MissingColumnException(
                __('Configured field `{0}` is missing from the table `{1}`.',
                    $field,
                    $this->getAlias()

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

                )
            );
        }

        return $field;
    }

    public function query()
    {
        return new Query($this->getConnection(), $this);

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

$this of type SoftDelete\Model\Table\SoftDeleteTrait is incompatible with the type Cake\ORM\Table expected by parameter $table of SoftDelete\ORM\Query::__construct().

    }

    /**
     * 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();

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

        if (!$entity->has($primaryKey)) {
            $msg = 'Deleting requires all primary key values.';
            throw new \InvalidArgumentException($msg);
        }

        if ($options['checkRules'] && !$this->checkRules($entity, RulesChecker::DELETE, $options)) {

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

            return false;
        }

        $event = $this->dispatchEvent('Model.beforeDelete', [

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

            '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()])

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

            ->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)) {

The method delete() does not exist on SoftDelete\Model\Table\SoftDeleteTrait. Did you maybe mean deleteAll()?

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

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

        return $this->save($entity);

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

    }

    /**
     * @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());

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

        $activeValue = $this->getRestoreValue();

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

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