Update `filters` parameter.

@param  string $filters  Searching text with specific key within the scope.

@return OmiseSearch  This instance.
497941
public function filter(array $filters = array())
    {
        foreach ($filters as $k => $v) {
            if (is_bool($v)) {
                $filters[$k] = $v ? 'true' : 'false';
            }
        }
        return $this->mergeAttributes('filters', $filters);
    }
173721
public function setFilters($filters)
    {
        if(is_null($filters)){
            $filters = "";
        }
        if (is_string($filters)) {
            $filters = $this->parseFilters($filters);
        }

        $this->filters = array_merge($this->filters, $filters);
    }
1368609
public function applyFilters(array $filters, bool $strict = false)
    {
        foreach ($filters ?? [] as $filterName => $filterValue) {
            if ($filterValue === null) {
                continue;
            }

            if (!property_exists($this->getModelName(), $filterName)) {
                if ($strict) {
                    throw new \Exception("Param $filterName not found for class {$this->getModelName()}");
                }
                continue;
            }

            $this->andWhere("{$this->getAlias()}.{$filterName} = :{$filterName}:", [$filterName => $filterValue]);
        }

        return $this;
    }
858227
private static function combineFilters($filters)
    {
        return function ($value) use ($filters) {
            foreach ($filters as $filter) {
                if (!$filter($value)) {
                    return false;
                }
            }
            return true;
        };
    }
979244
public function add($filter)
    {
        if (is_array($filter)) {
            $this->collection[] = new Filter($filter);
        } elseif (is_object($filter) && $filter instanceof Filter) {
            $this->collection[] = $filter;
        }

        return $this;
    }
1180222
public function addFiltersWithAndToTable(iterable $filters): self
    {
        $addWith = $this->expr()->andX();
        $this->applyFilters($addWith, $this->getTableName(), $filters);
        $addWith->count() <= 0 ?: $this->andWhere($addWith);

        return $this;
    }
49453
public function withFilter(Filter $filter)
    {
        if ($this->value->isNull()) {
            return null;
        }

        return $this->applyFilter($filter);
    }
54683
public function addFilters($filters) {
        if (!is_array($filters) && !$filters instanceof Traversable) {
            return $this;
        }
        foreach ($filters as $filter) {
            $this->addFilter($filter);
        }
        return $this;
    }
529420
public function addFilter($key, $filter)
    {
        if (false === isset($this->filters[$key])) {
            $this->filters[$key] = [];
        }

        $this->filters[$key][] = $filter;

        return $this;
    }
851078
private function createFilteredQuery(array $filters)
    {
        $qb = $this->createQuery('entity');

        foreach ($filters as $field => $filter) {
            $qb->andWhere(is_array($filter)
                    ? sprintf('entity.%s in (:%s)', $field, $field)
                    : sprintf('entity.%s = :%s', $field, $field)
                )
                ->setParameter(sprintf(':%s', $field), $filter)
            ;
        }

        return $qb->getQuery();
    }
435311
public function setAllowFilters(array $filters = []): void
    {
        $this->allowFilters = [];
        foreach ($filters as $column) {
            $this->addAllowFilter($column);
        }
    }
500263
public function withFilters(array $filters = null)
    {
        if ($filters) {
            foreach ($filters as $filter) {
                switch ($filter['type']) {
                    case 'select':
                        $this->select($filter['fields']);
                        break;
                    case 'andWhere':
                        $this->andWhere($filter['field'], $filter['operation'], $filter['value']);
                        break;
                    case 'orWhere':
                        $this->orWhere($filter['field'], $filter['operation'], $filter['value']);
                        break;
                    case 'andHaving':
                        $this->andHaving($filter['field'], $filter['operation'], $filter['value']);
                        break;
                    case 'orHaving':
                        $this->orHaving($filter['field'], $filter['operation'], $filter['value']);
                        break;
                    case 'addGroupBy':
                        $this->addGroupBy($filter['field']);
                        break;
                    case 'addOrderBy':
                        $this->addOrderBy($filter['field'], $filter['order']);
                        break;
                    case 'fkAddOrderBy':
                        $this->fkAddOrderBy($filter['field'], $filter['fkField'], $filter['order']);
                        break;
                    case 'paginate':
                        if (isset($filter['page'])) {
                            $this->paginate($filter['limit'], $filter['page']);
                        } else {
                            $this->paginate($filter['limit']);
                        }
                        break;
                }
            }
        }

        return $this;
    }
929366
public function Where(string $filter, array $params = []): QueryBuilder
    {
        $this->filter;
        $this->params = $params;
        
        return $this;
    }
213734
public function whereSearch($filters)
    {
        $data = $this->request->get();

        foreach ($filters as $k => $v) {
            preg_match('#^(\w+)(.*)$#', is_string($k) ? $k : $v, $match);
            $field = $match[1];

            if (is_int($k)) {
                if (!isset($data[$field])) {
                    continue;
                }
                $value = $data[$field];
                if (is_string($value)) {
                    $value = trim($value);
                    if ($value === '') {
                        continue;
                    }
                }
                $this->where($v, $value);
            } else {
                $this->where($k, $v);
            }
        }

        return $this;
    }
537329
public function filter($filters = null)
    {
        if ($filters) {
            $this->query->where(function($query) use ($filters) {
                foreach ($filters as $where) {
                    // Use 'and' as default boolean method
                    if (!isset($where[3])) { $where[3] = 'and'; }

                    // Sugar for 'IN' operations
                    if ($where[1] == '=' && gettype($where[2]) == 'array') {
                        $where[1] = 'in';

                    } else if ($where[1] == '!=' && $where[2] == null) {
                        // Workaround to support whereNotNull
                        $where[1] = 'not_null';
                        $where[2] = 'and';
                    }

                    if (preg_match('/^[a-z_]+$/', $where[1]) !== 0 && strtolower($where[1]) !== 'like') {
                        $method = 'where' . ucfirst(\Illuminate\Support\Str::camel($where[1]));
                        $query->{$method}($where[0], $where[2], $where[3]);
                    } else {
                        $query->where($where[0], $where[1], $where[2], $where[3]);
                    }
                }
            });
        }

        return $this;
    }
851785
public function setFilters($filters = []) {
		if ($filters) {
			foreach ($filters as $key => $value) {
				$this->setFilter($key, $value);
			}
		}

		return $this;
	}
331514
public function set($filters)
    {
        $filters = (array) $filters;

        foreach ($this->map as $attribute => $key) {
            if (!isset($filters[$attribute])) {
                continue;
            }

            $value = $filters[$attribute];
            $this->setByKey($key, $value);
        }
    }