SearchContext::__construct() - Code Metrics - Inspection of "Allow methods to be used for flexible searchable_f..." - silverstripe/silverstripe-framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — 4 (#10199)

unknown

created 2022-02-07 17:47 UTC

SearchContext::__construct() A

↳ Parent: SearchContext

Complexity

Conditions	3
Paths	4

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	3
nc	4
nop	3
dl	0
loc	5
rs	10
c	0
b	0
f	0

<?php

namespace SilverStripe\ORM\Search;

use SilverStripe\Control\HTTPRequest;
use SilverStripe\Core\ClassInfo;
use SilverStripe\Core\Injector\Injectable;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\Forms\FieldList;
use SilverStripe\Forms\FormField;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\DataList;
use SilverStripe\ORM\Filters\SearchFilter;
use SilverStripe\ORM\ArrayList;
use SilverStripe\View\ArrayData;
use SilverStripe\Forms\SelectField;
use SilverStripe\Forms\CheckboxField;
use InvalidArgumentException;
use Exception;

/**
 * Manages searching of properties on one or more {@link DataObject}
 * types, based on a given set of input parameters.
 * SearchContext is intentionally decoupled from any controller-logic,
 * it just receives a set of search parameters and an object class it acts on.
 *
 * The default output of a SearchContext is either a {@link SQLSelect} object
 * for further refinement, or a {@link SS_List} that can be used to display
 * search results, e.g. in a {@link TableListField} instance.
 *
 * In case you need multiple contexts, consider namespacing your request parameters
 * by using {@link FieldList->namespace()} on the $fields constructor parameter.
 *
 * Each DataObject subclass can have multiple search contexts for different cases,
 * e.g. for a limited frontend search and a fully featured backend search.
 * By default, you can use {@link DataObject->getDefaultSearchContext()} which is automatically
 * scaffolded. It uses {@link DataObject::$searchable_fields} to determine which fields
 * to include.
 *
 * @see http://doc.silverstripe.com/doku.php?id=searchcontext
 */
class SearchContext
{
    use Injectable;

    /**
     * DataObject subclass to which search parameters relate to.
     * Also determines as which object each result is provided.
     *
     * @var string
     */
    protected $modelClass;

    /**
     * FormFields mapping to {@link DataObject::$db} properties
     * which are supposed to be searchable.
     *
     * @var FieldList
     */
    protected $fields;

    /**
     * Array of {@link SearchFilter} subclasses.
     *
     * @var SearchFilter[]
     */
    protected $filters;

    /**
     * Key/value pairs of search fields to search terms
     *
     * @var array
     */
    protected $searchParams = [];

    /**
     * The logical connective used to join WHERE clauses. Defaults to AND.
     * @var string
     */
    public $connective = 'AND';

    /**
     * A key value pair of values that should be searched for.
     * The keys should match the field names specified in {@link self::$fields}.
     * Usually these values come from a submitted searchform
     * in the form of a $_REQUEST object.
     * CAUTION: All values should be treated as insecure client input.
     *
     * @param string $modelClass The base {@link DataObject} class that search properties related to.
     *                      Also used to generate a set of result objects based on this class.
     * @param FieldList $fields Optional. FormFields mapping to {@link DataObject::$db} properties
     *                      which are to be searched. Derived from modelclass using
     *                      {@link DataObject::scaffoldSearchFields()} if left blank.
     * @param array $filters Optional. Derived from modelclass if left blank
     */
    public function __construct($modelClass, $fields = null, $filters = null)
    {
        $this->modelClass = $modelClass;
        $this->fields = ($fields) ? $fields : new FieldList();
        $this->filters = ($filters) ? $filters : [];
    }

    /**
     * Returns scaffolded search fields for UI.
     *
     * @return FieldList
     */
    public function getSearchFields()
    {
        return ($this->fields) ? $this->fields : singleton($this->modelClass)->scaffoldSearchFields();
        // $this->fields is causing weirdness, so we ignore for now, using the default scaffolding
        //return singleton($this->modelClass)->scaffoldSearchFields();
    }

    /**
     * @todo move to SQLSelect
     * @todo fix hack
     */
    protected function applyBaseTableFields()
    {
        $classes = ClassInfo::dataClassesFor($this->modelClass);
        $baseTable = DataObject::getSchema()->baseDataTable($this->modelClass);
        $fields = ["\"{$baseTable}\".*"];
        if ($this->modelClass != $classes[0]) {
            $fields[] = '"' . $classes[0] . '".*';
        }
        //$fields = array_keys($model->db());
        $fields[] = '"' . $classes[0] . '".\"ClassName\" AS "RecordClassName"';
        return $fields;
    }

    /**
     * Returns a SQL object representing the search context for the given
     * list of query parameters.
     *
     * @param array $searchParams Map of search criteria, mostly taken from $_REQUEST.
     *  If a filter is applied to a relationship in dot notation,
     *  the parameter name should have the dots replaced with double underscores,
     *  for example "Comments__Name" instead of the filter name "Comments.Name".
     * @param array|bool|string $sort Database column to sort on.
     *  Falls back to {@link DataObject::$default_sort} if not provided.
     * @param array|bool|string $limit
     * @param DataList $existingQuery
     * @return DataList
     * @throws Exception
     */
    public function getQuery($searchParams, $sort = false, $limit = false, $existingQuery = null)
    {
        /** DataList $query */
        $query = null;
        if ($existingQuery) {
            if (!($existingQuery instanceof DataList)) {

                throw new InvalidArgumentException("existingQuery must be DataList");
            }
            if ($existingQuery->dataClass() != $this->modelClass) {
                throw new InvalidArgumentException("existingQuery's dataClass is " . $existingQuery->dataClass()
                    . ", $this->modelClass expected.");
            }
            $query = $existingQuery;
        } else {
            $query = DataList::create($this->modelClass);
        }

        if (is_array($limit)) {
            $query = $query->limit(
                isset($limit['limit']) ? $limit['limit'] : null,
                isset($limit['start']) ? $limit['start'] : null
            );
        } else {
            $query = $query->limit($limit);
        }

        /** @var DataList $query */
        $query = $query->sort($sort);
        $this->setSearchParams($searchParams);

        foreach ($this->searchParams as $key => $value) {
            $key = str_replace('__', '.', $key);
            if ($filter = $this->getFilter($key)) {
                $filter->setModel($this->modelClass);
                $filter->setValue($value);
                if (!$filter->isEmpty()) {
                    $modelObj = Injector::inst()->create($this->modelClass);
                    if(isset($modelObj->searchableFields()[$key]['match_any'])) {
                        $query = $query->alterDataQuery(function ($dataQuery) use ($modelObj, $key, $value) {
                            $searchFields = $modelObj->searchableFields()[$key]['match_any'];
                            $sqlSearchFields = [];
                            foreach($searchFields as $dottedRelation){
                                $relation = substr($dottedRelation, 0, strpos($dottedRelation, '.'));
                                $relations = explode('.', $dottedRelation);
                                $fieldName = array_pop($relations);

                                // Apply join
                                $relationModelName = $dataQuery->applyRelation($relation);

                                // Get prefixed column
                                $relationPrefix = $dataQuery->applyRelationPrefix($relation);

                                // Find the db field the relation belongs to
                                $columnName = $modelObj->getSchema()
                                    ->sqlColumnForField($relationModelName, $fieldName, $relationPrefix);

                                // Update filters to used the sqlColumnForField
                                $sqlSearchFields[$columnName] = $value;
                            }
                            $dataQuery = $dataQuery->whereAny($sqlSearchFields);

                        });
                    } else {
                        $query = $query->alterDataQuery([$filter, 'apply']);
                    }
                }
            }
        }

        if ($this->connective != "AND") {
            throw new Exception("SearchContext connective '$this->connective' not supported after ORM-rewrite.");
        }

        return $query;
    }

    /**
     * Returns a result set from the given search parameters.
     *
     * @todo rearrange start and limit params to reflect DataObject
     *
     * @param array $searchParams
     * @param array|bool|string $sort
     * @param array|bool|string $limit
     * @return DataList
     * @throws Exception
     */
    public function getResults($searchParams, $sort = false, $limit = false)
    {
        $searchParams = array_filter((array)$searchParams, [$this, 'clearEmptySearchFields']);

        // getQuery actually returns a DataList
        return $this->getQuery($searchParams, $sort, $limit);
    }

    /**
     * Callback map function to filter fields with empty values from
     * being included in the search expression.
     *
     * @param mixed $value
     * @return boolean
     */
    public function clearEmptySearchFields($value)
    {
        return ($value != '');
    }

    /**
     * Accessor for the filter attached to a named field.
     *
     * @param string $name
     * @return SearchFilter
     */
    public function getFilter($name)
    {
        if (isset($this->filters[$name])) {
            return $this->filters[$name];
        } else {
            return null;
        }
    }

    /**
     * Get the map of filters in the current search context.
     *
     * @return SearchFilter[]
     */
    public function getFilters()
    {
        return $this->filters;
    }

    /**
     * Overwrite the current search context filter map.
     *
     * @param array $filters
     */
    public function setFilters($filters)
    {
        $this->filters = $filters;
    }

    /**
     * Adds a instance of {@link SearchFilter}.
     *
     * @param SearchFilter $filter
     */
    public function addFilter($filter)
    {
        $this->filters[$filter->getFullName()] = $filter;
    }

    /**
     * Removes a filter by name.
     *
     * @param string $name
     */
    public function removeFilterByName($name)
    {
        unset($this->filters[$name]);
    }

    /**
     * Get the list of searchable fields in the current search context.
     *
     * @return FieldList
     */
    public function getFields()
    {
        return $this->fields;
    }

    /**
     * Apply a list of searchable fields to the current search context.
     *
     * @param FieldList $fields
     */
    public function setFields($fields)
    {
        $this->fields = $fields;
    }

    /**
     * Adds a new {@link FormField} instance.
     *
     * @param FormField $field
     */
    public function addField($field)
    {
        $this->fields->push($field);
    }

    /**
     * Removes an existing formfield instance by its name.
     *
     * @param string $fieldName
     */
    public function removeFieldByName($fieldName)
    {
        $this->fields->removeByName($fieldName);
    }

    /**
     * Set search param values
     *
     * @param array|HTTPRequest $searchParams
     * @return $this
     */
    public function setSearchParams($searchParams)
    {
        // hack to work with $searchParams when it's an Object
        if ($searchParams instanceof HTTPRequest) {
            $this->searchParams = $searchParams->getVars();
        } else {
            $this->searchParams = $searchParams;
        }
        return $this;
    }

    /**
     * @return array
     */
    public function getSearchParams()
    {
        return $this->searchParams;
    }

    /**
     * Gets a list of what fields were searched and the values provided
     * for each field. Returns an ArrayList of ArrayData, suitable for
     * rendering on a template.
     *
     * @return ArrayList
     */
    public function getSummary()
    {
        $list = ArrayList::create();
        foreach ($this->searchParams as $searchField => $searchValue) {
            if (empty($searchValue)) {
                continue;
            }
            $filter = $this->getFilter($searchField);
            if (!$filter) {
                continue;
            }

            $field = $this->fields->fieldByName($filter->getFullName());
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
            if (!$field) {
                continue;
            }

            // For dropdowns, checkboxes, etc, get the value that was presented to the user
            // e.g. not an ID
            if ($field instanceof SelectField) {
                $source = $field->getSource();
                if (isset($source[$searchValue])) {
                    $searchValue = $source[$searchValue];
                }
            } else {
                // For checkboxes, it suffices to simply include the field in the list, since it's binary
                if ($field instanceof CheckboxField) {
                    $searchValue = null;
                }
            }

            $list->push(ArrayData::create([
                'Field' => $field->Title(),
                'Value' => $searchValue,
            ]));
        }

        return $list;
    }
}


1			<?php
2
3			namespace SilverStripe\ORM\Search;
4
5			use SilverStripe\Control\HTTPRequest;
6			use SilverStripe\Core\ClassInfo;
7			use SilverStripe\Core\Injector\Injectable;
8			use SilverStripe\Core\Injector\Injector;
9			use SilverStripe\Forms\FieldList;
10			use SilverStripe\Forms\FormField;
11			use SilverStripe\ORM\DataObject;
12			use SilverStripe\ORM\DataList;
13			use SilverStripe\ORM\Filters\SearchFilter;
14			use SilverStripe\ORM\ArrayList;
15			use SilverStripe\View\ArrayData;
16			use SilverStripe\Forms\SelectField;
17			use SilverStripe\Forms\CheckboxField;
18			use InvalidArgumentException;
19			use Exception;
20
21			/**
22			* Manages searching of properties on one or more {@link DataObject}
23			* types, based on a given set of input parameters.
24			* SearchContext is intentionally decoupled from any controller-logic,
25			* it just receives a set of search parameters and an object class it acts on.
26			*
27			* The default output of a SearchContext is either a {@link SQLSelect} object
28			* for further refinement, or a {@link SS_List} that can be used to display
29			* search results, e.g. in a {@link TableListField} instance.
30			*
31			* In case you need multiple contexts, consider namespacing your request parameters
32			* by using {@link FieldList->namespace()} on the $fields constructor parameter.
33			*
34			* Each DataObject subclass can have multiple search contexts for different cases,
35			* e.g. for a limited frontend search and a fully featured backend search.
36			* By default, you can use {@link DataObject->getDefaultSearchContext()} which is automatically
37			* scaffolded. It uses {@link DataObject::$searchable_fields} to determine which fields
38			* to include.
39			*
40			* @see http://doc.silverstripe.com/doku.php?id=searchcontext
41			*/
42			class SearchContext
43			{
44			use Injectable;
45
46			/**
47			* DataObject subclass to which search parameters relate to.
48			* Also determines as which object each result is provided.
49			*
50			* @var string
51			*/
52			protected $modelClass;
53
54			/**
55			* FormFields mapping to {@link DataObject::$db} properties
56			* which are supposed to be searchable.
57			*
58			* @var FieldList
59			*/
60			protected $fields;
61
62			/**
63			* Array of {@link SearchFilter} subclasses.
64			*
65			* @var SearchFilter[]
66			*/
67			protected $filters;
68
69			/**
70			* Key/value pairs of search fields to search terms
71			*
72			* @var array
73			*/
74			protected $searchParams = [];
75
76			/**
77			* The logical connective used to join WHERE clauses. Defaults to AND.
78			* @var string
79			*/
80			public $connective = 'AND';
81
82			/**
83			* A key value pair of values that should be searched for.
84			* The keys should match the field names specified in {@link self::$fields}.
85			* Usually these values come from a submitted searchform
86			* in the form of a $_REQUEST object.
87			* CAUTION: All values should be treated as insecure client input.
88			*
89			* @param string $modelClass The base {@link DataObject} class that search properties related to.
90			* Also used to generate a set of result objects based on this class.
91			* @param FieldList $fields Optional. FormFields mapping to {@link DataObject::$db} properties
92			* which are to be searched. Derived from modelclass using
93			* {@link DataObject::scaffoldSearchFields()} if left blank.
94			* @param array $filters Optional. Derived from modelclass if left blank
95			*/
96			public function __construct($modelClass, $fields = null, $filters = null)
97			{
98			$this->modelClass = $modelClass;
99			$this->fields = ($fields) ? $fields : new FieldList();
100			$this->filters = ($filters) ? $filters : [];
101			}
102
103			/**
104			* Returns scaffolded search fields for UI.
105			*
106			* @return FieldList
107			*/
108			public function getSearchFields()
109			{
110			return ($this->fields) ? $this->fields : singleton($this->modelClass)->scaffoldSearchFields();
111			// $this->fields is causing weirdness, so we ignore for now, using the default scaffolding
112			//return singleton($this->modelClass)->scaffoldSearchFields();
113			}
114
115			/**
116			* @todo move to SQLSelect
117			* @todo fix hack
118			*/
119			protected function applyBaseTableFields()
120			{
121			$classes = ClassInfo::dataClassesFor($this->modelClass);
122			$baseTable = DataObject::getSchema()->baseDataTable($this->modelClass);
123			$fields = ["\"{$baseTable}\".*"];
124			if ($this->modelClass != $classes[0]) {
125			$fields[] = '"' . $classes[0] . '".*';
126			}
127			//$fields = array_keys($model->db());
128			$fields[] = '"' . $classes[0] . '".\"ClassName\" AS "RecordClassName"';
129			return $fields;
130			}
131
132			/**
133			* Returns a SQL object representing the search context for the given
134			* list of query parameters.
135			*
136			* @param array $searchParams Map of search criteria, mostly taken from $_REQUEST.
137			* If a filter is applied to a relationship in dot notation,
138			* the parameter name should have the dots replaced with double underscores,
139			* for example "Comments__Name" instead of the filter name "Comments.Name".
140			* @param array\|bool\|string $sort Database column to sort on.
141			* Falls back to {@link DataObject::$default_sort} if not provided.
142			* @param array\|bool\|string $limit
143			* @param DataList $existingQuery
144			* @return DataList
145			* @throws Exception
146			*/
147			public function getQuery($searchParams, $sort = false, $limit = false, $existingQuery = null)
148			{
149			/** DataList $query */
150			$query = null;
151			if ($existingQuery) {
152			if (!($existingQuery instanceof DataList)) {
			0 ignored issues – show introduced 2018-10-19 16:08 UTC by Report Bug Copy Issue Report `$existingQuery` is always a sub-type of `SilverStripe\ORM\DataList`. Loading history...
153			throw new InvalidArgumentException("existingQuery must be DataList");
154			}
155			if ($existingQuery->dataClass() != $this->modelClass) {
156			throw new InvalidArgumentException("existingQuery's dataClass is " . $existingQuery->dataClass()
157			. ", $this->modelClass expected.");
158			}
159			$query = $existingQuery;
160			} else {
161			$query = DataList::create($this->modelClass);
162			}
163
164			if (is_array($limit)) {
165			$query = $query->limit(
166			isset($limit['limit']) ? $limit['limit'] : null,
167			isset($limit['start']) ? $limit['start'] : null
168			);
169			} else {
170			$query = $query->limit($limit);
171			}
172
173			/** @var DataList $query */
174			$query = $query->sort($sort);
175			$this->setSearchParams($searchParams);
176
177			foreach ($this->searchParams as $key => $value) {
178			$key = str_replace('__', '.', $key);
179			if ($filter = $this->getFilter($key)) {
180			$filter->setModel($this->modelClass);
181			$filter->setValue($value);
182			if (!$filter->isEmpty()) {
183			$modelObj = Injector::inst()->create($this->modelClass);
184			if(isset($modelObj->searchableFields()[$key]['match_any'])) {
185			$query = $query->alterDataQuery(function ($dataQuery) use ($modelObj, $key, $value) {
186			$searchFields = $modelObj->searchableFields()[$key]['match_any'];
187			$sqlSearchFields = [];
188			foreach($searchFields as $dottedRelation){
189			$relation = substr($dottedRelation, 0, strpos($dottedRelation, '.'));
190			$relations = explode('.', $dottedRelation);
191			$fieldName = array_pop($relations);
192
193			// Apply join
194			$relationModelName = $dataQuery->applyRelation($relation);
195
196			// Get prefixed column
197			$relationPrefix = $dataQuery->applyRelationPrefix($relation);
198
199			// Find the db field the relation belongs to
200			$columnName = $modelObj->getSchema()
201			->sqlColumnForField($relationModelName, $fieldName, $relationPrefix);
202
203			// Update filters to used the sqlColumnForField
204			$sqlSearchFields[$columnName] = $value;
205			}
206			$dataQuery = $dataQuery->whereAny($sqlSearchFields);
			0 ignored issues – show Unused Code introduced 2022-01-13 18:45 UTC by Report Bug Copy Issue Report The assignment to `$dataQuery` is dead and can be removed. Loading history...
207			});
208			} else {
209			$query = $query->alterDataQuery([$filter, 'apply']);
210			}
211			}
212			}
213			}
214
215			if ($this->connective != "AND") {
216			throw new Exception("SearchContext connective '$this->connective' not supported after ORM-rewrite.");
217			}
218
219			return $query;
220			}
221
222			/**
223			* Returns a result set from the given search parameters.
224			*
225			* @todo rearrange start and limit params to reflect DataObject
226			*
227			* @param array $searchParams
228			* @param array\|bool\|string $sort
229			* @param array\|bool\|string $limit
230			* @return DataList
231			* @throws Exception
232			*/
233			public function getResults($searchParams, $sort = false, $limit = false)
234			{
235			$searchParams = array_filter((array)$searchParams, [$this, 'clearEmptySearchFields']);
236
237			// getQuery actually returns a DataList
238			return $this->getQuery($searchParams, $sort, $limit);
239			}
240
241			/**
242			* Callback map function to filter fields with empty values from
243			* being included in the search expression.
244			*
245			* @param mixed $value
246			* @return boolean
247			*/
248			public function clearEmptySearchFields($value)
249			{
250			return ($value != '');
251			}
252
253			/**
254			* Accessor for the filter attached to a named field.
255			*
256			* @param string $name
257			* @return SearchFilter
258			*/
259			public function getFilter($name)
260			{
261			if (isset($this->filters[$name])) {
262			return $this->filters[$name];
263			} else {
264			return null;
265			}
266			}
267
268			/**
269			* Get the map of filters in the current search context.
270			*
271			* @return SearchFilter[]
272			*/
273			public function getFilters()
274			{
275			return $this->filters;
276			}
277
278			/**
279			* Overwrite the current search context filter map.
280			*
281			* @param array $filters
282			*/
283			public function setFilters($filters)
284			{
285			$this->filters = $filters;
286			}
287
288			/**
289			* Adds a instance of {@link SearchFilter}.
290			*
291			* @param SearchFilter $filter
292			*/
293			public function addFilter($filter)
294			{
295			$this->filters[$filter->getFullName()] = $filter;
296			}
297
298			/**
299			* Removes a filter by name.
300			*
301			* @param string $name
302			*/
303			public function removeFilterByName($name)
304			{
305			unset($this->filters[$name]);
306			}
307
308			/**
309			* Get the list of searchable fields in the current search context.
310			*
311			* @return FieldList
312			*/
313			public function getFields()
314			{
315			return $this->fields;
316			}
317
318			/**
319			* Apply a list of searchable fields to the current search context.
320			*
321			* @param FieldList $fields
322			*/
323			public function setFields($fields)
324			{
325			$this->fields = $fields;
326			}
327
328			/**
329			* Adds a new {@link FormField} instance.
330			*
331			* @param FormField $field
332			*/
333			public function addField($field)
334			{
335			$this->fields->push($field);
336			}
337
338			/**
339			* Removes an existing formfield instance by its name.
340			*
341			* @param string $fieldName
342			*/
343			public function removeFieldByName($fieldName)
344			{
345			$this->fields->removeByName($fieldName);
346			}
347
348			/**
349			* Set search param values
350			*
351			* @param array\|HTTPRequest $searchParams
352			* @return $this
353			*/
354			public function setSearchParams($searchParams)
355			{
356			// hack to work with $searchParams when it's an Object
357			if ($searchParams instanceof HTTPRequest) {
358			$this->searchParams = $searchParams->getVars();
359			} else {
360			$this->searchParams = $searchParams;
361			}
362			return $this;
363			}
364
365			/**
366			* @return array
367			*/
368			public function getSearchParams()
369			{
370			return $this->searchParams;
371			}
372
373			/**
374			* Gets a list of what fields were searched and the values provided
375			* for each field. Returns an ArrayList of ArrayData, suitable for
376			* rendering on a template.
377			*
378			* @return ArrayList
379			*/
380			public function getSummary()
381			{
382			$list = ArrayList::create();
383			foreach ($this->searchParams as $searchField => $searchValue) {
384			if (empty($searchValue)) {
385			continue;
386			}
387			$filter = $this->getFilter($searchField);
388			if (!$filter) {
389			continue;
390			}
391
392			$field = $this->fields->fieldByName($filter->getFullName());
			0 ignored issues – show Bug introduced 2020-07-23 10:50 UTC by Report Bug Copy Issue Report Are you sure the assignment to `$field` is correct as `$this->fields->fieldByNa...$filter->getFullName())` targeting `SilverStripe\Forms\FieldList::fieldByName()` seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
393			if (!$field) {
394			continue;
395			}
396
397			// For dropdowns, checkboxes, etc, get the value that was presented to the user
398			// e.g. not an ID
399			if ($field instanceof SelectField) {
400			$source = $field->getSource();
401			if (isset($source[$searchValue])) {
402			$searchValue = $source[$searchValue];
403			}
404			} else {
405			// For checkboxes, it suffices to simply include the field in the list, since it's binary
406			if ($field instanceof CheckboxField) {
407			$searchValue = null;
408			}
409			}
410
411			$list->push(ArrayData::create([
412			'Field' => $field->Title(),
413			'Value' => $searchValue,
414			]));
415			}
416
417			return $list;
418			}
419			}
420

silverstripe / silverstripe-framework

Pull Request — 4 (#10199)

SearchContext::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like