gets filter params from session

@return String
3437
protected function getParams($key = null)
    {
        $params = $this->session->get(uri());
        return !is_null($key) ? array_get($params, $key) : $params;
    }
854093
protected function getFiltersType()
    {
        // var_dump($this->get('request')->query->all());exit;
        $form = $this->get('form.factory')->createNamed('filters', 'form', null, array(
            'action'          => $this->generateUrl($this->getRoutePrefix(), array(
                'sort'  => $this->get('request')->get('sort'),
                'order' => $this->get('request')->get('order'),
            )),
            'method'          => 'GET',
            'csrf_protection' => false,
            'attr'            => array(
                'class'    => 'form-inline',
            ),
        ));

        return $form;
    }
539785
public function getFilters()
    {
        if (null === $this->sorted) {
            if (!count($this->filters)) {
                $this->sorted = array();
            } else {
                ksort($this->filters);
                $this->sorted = call_user_func_array('array_merge', $this->filters);
            }
        }
        return $this->sorted;
    }
1369115
private function filter()
    {
        if ($this->allowsFilter()) {
            if ($this->hasFilters()) {
                $tmp = [];
                foreach ($this->filters as $filter) {
                    // check, if it is a "forbidden" query parameter
                    if ($this->isExcludedParameter($filter['key'])) {
                        continue;
                    }
                    $tmp[] = $filter;
                }

                $this->filters = $tmp;

                return $this->operator->filter($this->filters);
            }
        }
    }
552422
protected function _getFilterData()
    {
        $rawFilterData = $this->request->getData();
        $filterData = [];
        foreach ($this->filterFields as $filterField => $options) {
            if (isset($rawFilterData[$filterField]) && $rawFilterData[$filterField] !== '') {
                $filterData[$filterField] = $rawFilterData[$filterField];
            }
        }

        return $filterData;
    }
164999
public function getQueryParams() {
    if ($pos = strpos($this->url, '?')) {
      $queryStr = substr($this->url, $pos + 1);
      $params = array();
      parse_str($queryStr, $params);
      return $params;
    }
    return array();
  }
89814
public function getFiltersArray()
    {
        if ($this->_filtersArray === null) {
            $this->_filtersArray = $this->getQueryCacheHelper((new Query())->from('{{%admin_storage_filter}}')->select(['id', 'identifier', 'name'])->indexBy('identifier')->orderBy(['name' => SORT_ASC]), self::CACHE_KEY_FILTER);
        }

        return $this->_filtersArray;
    }
1114680
private function getParameterList()
    {
        return array_filter(
            $this->container->getParameterBag()->all(), function ($name) {
                if (preg_match('/^container\./', $name)) {
                    return false;
                }
                if (preg_match('/^drupal\./', $name)) {
                    return false;
                }
                if (preg_match('/^console\./', $name)) {
                    return false;
                }
                return true;
            }, ARRAY_FILTER_USE_KEY
        );
    }
452781
public function getFilters()
    {
        $filters = [];

        $filters[] = new \Twig_Filter('date_format', [$this, 'filterDateFormat']);
        $filters[] = new \Twig_Filter('truncate', 'b_truncate');
        $filters[] = new \Twig_Filter('nl2p', 'b_nl2p', ['is_safe' => ['html']]);
        $filters[] = new \Twig_Filter('human_file_size', 'b_human_file_size');
        $filters[] = new \Twig_Filter('json_decode', 'json_decode');

        return $filters;
    }
843905
public function getQueryParameters() {
        $params = array();
        if (isset($this->optional['filter']))
            $params['filter'] = $this->optional['filter'];
        if (isset($this->optional['count']))
            $params['count'] = $this->optional['count'];
        if (isset($this->optional['offset']))
            $params['offset'] = $this->optional['offset'];
        if (isset($this->optional['returnProperties']))
            $params['returnProperties'] = $this->optional['returnProperties'];
        if (isset($this->optional['includedProperties']))
            $params['includedProperties'] = $this->optional['includedProperties'];
        return $params;
    }
391825
private function getDateParams()
    {
        $session     = $this->get('session');
        $dateRange   = [];
        $fromSession = $session->get('mautic.daterange.form.from');
        $toSession   = $session->get('mautic.daterange.form.to');
        if (!empty($fromSession) && !empty($toSession)) {
            $dateRange = [
                'dateFrom' => new \DateTime($fromSession),
                'dateTo'   => new \DateTime($toSession),
            ];
        }

        if (empty($dateRange) || empty($dateRange['dateFrom'])) {
            // get System Default Date Ranges
            $dashboardModel = $this->get('mautic.dashboard.model.dashboard');
            $dateRange      = $dashboardModel->getDefaultFilter();
        }

        // clone so the session var doesnt get modified, just the values passed into tables
        $from      = clone $dateRange['dateFrom'];
        $to        = clone $dateRange['dateTo'];
        $params    =[];

        $from->setTimezone(new \DateTimeZone('UTC'));

        $to
            ->add(new \DateInterval('P1D'))
            ->sub(new \DateInterval('PT1S'))
            ->setTimezone(new \DateTimeZone('UTC'));

        $params['dateFrom'] = $from->format('Y-m-d H:i:s');

        $params['dateTo'] = $to->format('Y-m-d H:i:s');

        return $params;
    }
73945
protected function filter()
	{
		foreach ($this->filters as $attribute => $filters) {
			// Check if the attribute is present in the input data
			if (!array_key_exists($attribute, $this->data)) {
				continue;
			}

			$data = $this->data[$attribute];

			foreach ($filters as $filter) {
				// The format for specifying filter and parameters follows an
				// easy {filter}:{parameters} formatting convention.
				if (strpos($filter, ':') !== false) {
					list($filter, $parameterList) = explode(':', $filter, 2);
					$parameters = explode(',', $parameterList);
				} else {
					$parameters = [];
				}
				
				if (method_exists($this, $this->camelCase($filter))) {
					$data = $this->filterWalker($filter, $data, $parameters);
				} elseif (isset($this->extensions[$filter])) {
					$data = $this->filterExtensionWalker($filter, $data, $parameters);
				} else {
					throw new \Exception("'$filter' is not a valid filter.");
				}
			}

			$this->filteredData[$attribute] = $data;
		}

		return $this->filteredData;
	}
1083048
public function getFilters()
    {
        $filters = [];

        $names = explode('_', $this->name);
        $base = '';
        $filters = [];
        while ($name = array_shift($names)) {
            $filter = $this->_searchInControllerDir($base, 'filter.yml');
            if ($filter) $filters[] = $filter;

            // when has rest.
            if (count($names) > 0) {
                $base = $base . DS . ucfirst($name);

            // when last.
            } else {
                $filter = $this->_searchInControllerDir($base, "{$name}.filter.yml");
                if ($filter) $filters[] = $filter;
            }
        }

        return $filters;
    }
501438
protected function getPassThruParams()
    {

        if ($this->passThruParams !== null) {
            return $this->passThruParams;
        }

        $this->passThruParams = [];

        $all = Input::all();

        $filtered = array_except($all, ['sync','uploadedFile','folderName']);

        // Security check
        if (count($filtered) > 30) {
            throw new RuntimeException('Too many query params');
        }

        foreach ($filtered as $key=>$value) {
            $this->passThruParams[$key] = strip_tags($value);
        }

        return $this->passThruParams;

    }
15158
private function getParamsFromFilter()
    {
        if (!$this->body['filter']) {
            return [];
        }

        $result  = [];
        $must    = [];
        $mustNot = [];

        $params = $this->body['filter']->getParams();

        if (isset($params['groupBy']) && $params['groupBy']) {
            $result = $this->initGroupBy($params['factorValues'] ?? []);
        }

        if (isset($params['factorValues']) && $params['factorValues'] && !$this->groupBy) {
            $sortEl[] = new SortElement("_script", "desc", [
                'type'   => "number",
                'script' => (new MathSumWithFactor($params['factorValues']))->getAlgorithm(),
            ]);

            $this->body['sort'] = (new SortBuilder($sortEl))->toArray()['sort'];
        }

        if (isset($params['entities']) && $params['entities']) {
            $result['index'] = $params['entities'];
        }

        if (isset($params['keyword'])) {
            $must[] = new MultiMatchQuery($params['keyword']['value'], $params['keyword']['fields']);
        }

        foreach ($params['params'] ?? [] as $param) {
            list($query, $operator) = $param->createFilter();

            if ($operator == FilterOperators::IN) {
                $must[] = $query;
            } else {
                $mustNot[] = $query;
            }
        }

        if ($mustNot || $must) {

            $query = new QueryBuilder();
            if ($mustNot) {
                $query->setMustNot(new MustNotQuery($mustNot));
            }
            if ($must) {
                $query->setMust(new MustQuery($must));
            }

            $result['body']['query'] = $query->toArray();
        }

        return $result;
    }
413827
private function getParamsFromFilter(FilterBuilder $filter)
    {
        $result  = [];
        $must    = [];
        $mustNot = [];

        $params = $filter->getParams();

        if ($params['entities']) {
            $result['index'] = $params['entities'];
        }

        if (isset($params['keyword'])) {
            $must[] = new MultiMatchQuery($params['keyword']['value'], $params['keyword']['fields']);
        }

        foreach ($params['params'] ?? [] as $param) {
            list($query, $operator) = $param->createFilter();

            if ($operator == FilterOperators::IN) {
                $must[] = $query;
            } else {
                $mustNot[] = $query;
            }

        }

        if ($mustNot || $must) {

            $query = new QueryBuilder();
            if ($mustNot) {
                $query->setMustNot(new MustNotQuery($mustNot));
            }
            if ($must) {
                $query->setMust(new MustQuery($must));
            }

            $result['query'] = $query->toArray();
        }

        return $result;
    }
1223197
protected function extractFilters()
    {
        $invoker = function($methodName) {
            return $this->$methodName();
        };
        $invoker = $invoker->bindTo($this->controller, $this->controller);
        $filters = [];
        
        foreach ($this->controller->getReflection()->getMethods() as $method) {
            $methodName = $method->getName();
            if (
                strpos($methodName, 'Filters') === strlen($methodName) - 7
            ) {
                $filters = array_merge_recursive($filters, $invoker($methodName));
            }
        }
        
        foreach ($this->controller->getAppControllersMethod('filters') as $closure) {
            $filters = array_merge_recursive($filters, $closure());
        }
        
        $filters = array_merge_recursive($filters, $invoker('filters'));
        
        return $filters;
    }