EncryptedSearchFilter::setModifiers() - Code Metrics - Inspection of "major update to support ciphersweet" - lekoala/silverstripe-encrypt - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 45a3bb...2cf7c0 )

by Thomas
created 2020-12-15 11:11 UTC
EncryptedSearchFilter::setModifiers() A

↳ Parent: EncryptedSearchFilter
Complexity

Conditions	2
Paths	2
Size

Total Lines	8
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	4
c	1
b	0
f	0
dl	0
loc	8
rs	10
cc	2
nc	2
nop	1
<?php

namespace LeKoala\Encrypt;

use SilverStripe\ORM\DB;
use InvalidArgumentException;
use SilverStripe\ORM\DataQuery;
use ParagonIE\CipherSweet\BlindIndex;
use ParagonIE\CipherSweet\EncryptedField;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\Filters\SearchFilter;

/**
 * A filter that helps searching against a full blind index
 */
class EncryptedSearchFilter extends SearchFilter
{
    public function setModifiers(array $modifiers)
    {
        if (!empty($modifiers)) {
            throw new InvalidArgumentException(
                get_class($this) . ' does not accept ' . implode(', ', $modifiers) . ' as modifiers'
            );
        }
        parent::setModifiers($modifiers);
    }

    protected function getCaseSensitive()
    {
        return null;
    }

    public function getDbName()
    {
        $column = parent::getDbName();
        $column = str_replace('"', '', $column);
        return '"' . $column . 'BlindIndex"';
    }

    /**
     * @return EncryptedField
     */
    public function getEncryptedField()
    {
        $engine = EncryptHelper::getCipherSweet();
        $table = DataObject::getSchema()->tableName($this->model);
        $encryptedField = (new EncryptedField($engine, $table, $this->name))
            ->addBlindIndex(new BlindIndex($this->name . "BlindIndex", [], 32));
        return $encryptedField;
    }

    /**
     * Accessor for the current value to be filtered on.
     *
     * @return string|array
     */
    public function getEncryptedValue()
    {
        return $this->getEncryptedField()->getBlindIndex($this->getValue(), $this->name . 'BlindIndex');
        return $this->getEncryptedField()->getBlindIndex(/** @scrutinizer ignore-type */ $this->getValue(), $this->name . 'BlindIndex');
    }

    /**
     * Applies an exact match (equals) on a field value.
     *
     * @return DataQuery
     */
    protected function applyOne(DataQuery $query)
    {
        $this->model = $query->applyRelation($this->relation);
        $where = DB::get_conn()->comparisonClause(
            $this->getDbName(),
            null,
            true, // exact?
            false, // negate?
            $this->getCaseSensitive(),
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            true
        );
        $array = array($where => $this->getEncryptedValue());
        return $query->where($array);
    }

    /**
     * Applies an exact match (equals) on a field value against multiple
     * possible values.
     *
     * @return DataQuery
     */
    protected function applyMany(DataQuery $query)
    {
        $this->model = $query->applyRelation($this->relation);
        $caseSensitive = $this->getCaseSensitive();
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
        $values = $this->getEncryptedValue();
        $column = $this->getDbName();
        // For queries using the default collation (no explicit case) we can use the WHERE .. IN .. syntax,
        // providing simpler SQL than many WHERE .. OR .. fragments.
        // If values is an empty array, fall back to 3.1 behaviour and use empty string comparison
        if (empty($values)) {
            $values = array('');
        }
        $placeholders = DB::placeholders($values);
        $placeholders = DB::placeholders(/** @scrutinizer ignore-type */ $values);
        return $query->where(array(
            "$column IN ($placeholders)" => $values
        ));
    }

    /**
     * Excludes an exact match (equals) on a field value.
     *
     * @return DataQuery
     */
    protected function excludeOne(DataQuery $query)
    {
        $this->model = $query->applyRelation($this->relation);
        $column = $this->getDbName();
        $where = DB::get_conn()->comparisonClause(
            $column,
            null,
            true, // exact?
            true, // negate?
            $this->getCaseSensitive(),
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
            true
        );
        $array = array($where => $this->getEncryptedValue());
        return $query->where($array);
    }

    /**
     * Excludes an exact match (equals) on a field value against multiple
     * possible values.
     *
     * @return DataQuery
     */
    protected function excludeMany(DataQuery $query)
    {
        $this->model = $query->applyRelation($this->relation);
        $caseSensitive = $this->getCaseSensitive();
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
        $values = $this->getEncryptedValue();
        $column = $this->getDbName();
        if ($caseSensitive === null) {

            // For queries using the default collation (no explicit case) we can use the WHERE .. NOT IN .. syntax,
            // providing simpler SQL than many WHERE .. AND .. fragments.
            // If values is an empty array, fall back to 3.1 behaviour and use empty string comparison
            if (empty($values)) {
                $values = array('');
            }
            $placeholders = DB::placeholders($values);
            $placeholders = DB::placeholders(/** @scrutinizer ignore-type */ $values);
            return $query->where(array(
                "$column NOT IN ($placeholders)" => $values
            ));
        } else {
            // Generate reusable comparison clause
            $comparisonClause = DB::get_conn()->comparisonClause(
                $column,
                null,
                true, // exact?
                true, // negate?
                $this->getCaseSensitive(),
                true
            );
            // Since query connective is ambiguous, use AND explicitly here
            $count = count($values);
            $predicate = implode(' AND ', array_fill(0, $count, $comparisonClause));
            return $query->where(array($predicate => $values));
        }
    }

    public function isEmpty()
    {
        return $this->getValue() === array() || $this->getValue() === null || $this->getValue() === '';
    }
}

lekoala / silverstripe-encrypt

Push — master ( 45a3bb...2cf7c0 )

EncryptedSearchFilter::setModifiers() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
