Lists all tasks.

@param array $filters

@return array Response
516150
public function listAll(array $filters = []) : array {
        return $this->sendGet(
            sprintf('/profiles/%s/processes/%s/tasks', $this->userName, $this->processId),
            $filters
        );
    }
858921
public function filter($filters)
    {
        $filtered = [];
        foreach ($this->objectArr as $obj) {
            $success = true;
            foreach ($filters as $prop => $value) {
                if ($obj->$prop !== $value) {
                    $success = false;
                    break;
                }
            }
            if ($success) {
                $filtered[] = $obj;
            }
        }
        return $filtered;
    }
327249
public function whereSearch($filters)
    {
        foreach ($this->queries as $query) {
            $query->whereSearch($filters);
        }

        return $this;
    }
318414
public function list(array $filters = [])
    {
        if ($filters) {
            $filters_array = [];

            foreach ($filters as $k => $v) {
                if (!\in_array($k, ['dangling', 'driver', 'label', 'name'], true)) {
                    throw new Exception('Volume List Filters Not Found', 404);
                }

                if (\is_array($v)) {
                    $filters_array[$k] = $v;
                } else {
                    $filters_array[$k] = [$v];
                }
            }
        } else {
            $filters_array = null;
        }

        $url = $this->base_url.'?'.http_build_query(['filters' => json_encode($filters_array)]);

        return $this->curl->get($url);
    }
626488
public function getOptions($filters = null)
    {
        if (!$filters) {
            return $this->_parameters;
        }

        $result = [];

        foreach ($this->_parameters as $param) {
            $result[] = $this->filter($param, $filters);
        }

        return $result;
    }
1057618
public function getAll(array $filters = [])
    {
        $vars = $this->getEnvironmentVariables();

        foreach ($filters as $filter) {
            if (!$filter instanceof FilterInterface) {
                throw new FilterException(sprintf(
                    '%s %s %s',
                    'The $filters param must be an array',
                    'and your values must be an instance of',
                    '\Cekurte\Environment\Contract\FilterInterface'
                ));
            }

            $vars = $filter->filter($vars);
        }

        $callback = function ($rawValue) {
            return $this->getValue($rawValue);
        };

        return array_map($callback, $vars);
    }
63636
public function all($filters = array())
	{
		$keys = eaccelerator_list_keys();

		$data = array();

		if (is_array($keys))
		{
			foreach ($keys as $key)
			{
				// Trim leading ":" to work around list_keys namespace bug in eAcc.
				// This will still work when bug is fixed.
				$key['name'] = ltrim($key['name'], ':');

				if (strpos($key['name'], $this->prefix) === 0)
				{
					continue;
				}

				$session = new Object;
				$session->session_id = $file->getName();
				$session->data       = (string) eaccelerator_get($key['name']);

				$data[] = $session;
			}
		}

		return $data;
	}
242870
protected function parseFilters($filters)
    {
        $parsed = [];
        if (!empty($filters) && is_string($filters)) {
            $filters = trim($filters);
            if (!empty($filters)) {
                $filterArray = array_filter(explode(',', $filters), function ($value){
                    return trim($value);
                });

                foreach ($filterArray as $filter) {
                    list($field, $value) = explode('=', $filter);
                    $field = trim($field);
                    $value = trim($value);
                    if (!empty($field)) {
                        $parsed[$field] = $value;
                    }
                }
            }
        }

        return $parsed;
    }
846183
public function getSentMessages($filters=array())
	{
		$entries = $this->buildQuery($filters);
		$entries->order($entries->getTableName() . '.created', 'desc');

		if (isset($filters['limit']) && $filters['limit'] != 0)
		{
			$entries->limit($filters['limit'])
				->start($filters['start']);
		}

		return $entries->rows();
	}
753024
public function listResources($filter)
    {
        $alias = 'resource';
        $collection = $this->getThisCollection();

        $queryBuilder = $this->getRepository()
            ->createQueryBuilder($alias);

        // Build the filter on resources
        $this->filterQueryBuilder($queryBuilder, $filter, $collection, $alias);

        // Count the total number of resources
        $countQueryBuilder = clone $queryBuilder;
        $collectionIdentifier = $collection->getIdentifier();
        $totalNumberOfRows = $countQueryBuilder
            ->select($countQueryBuilder->expr()->count($alias . '.' . $collectionIdentifier))
            ->getQuery()
            ->getSingleScalarResult();

        // Paginate resources
        $this->paginateQueryBuilder($queryBuilder, $filter);

        // Finally, select all fields
        $queryBuilder->select($alias);

        $returnedResources = $this->loadResourcesFromQueryBuilder($queryBuilder, $this->getThisCollection());

        return Resource::formatResourcesJsonApi($returnedResources, $totalNumberOfRows);
    }
1280739
public static function parseFilters($filters)
	{
		return array_build(static::explodeFilters($filters), function($key, $value)
		{
			return Route::parseFilter($value);
		});
	}
307799
public function listListings(array $filters = [])
    {
        $query = '';

        if ($this->config->products) {
            $filters['product__id'] = $this->config->products;
        }

        if ($filters) {
            $query = '?' . preg_replace('/%5B[0-9]+%5D/simU', '', http_build_query($filters));
        }

        $body = $this->sendRequest('GET', '/listings' . $query);

        /** @var Listing[] $models */
        $models = Model::modelize('listings', json_decode($body));
        foreach ($models as $index => $model) {
            $models[$index]->requestProcessor = $this;
        }

        return $models;
    }
1053927
public function all($filters = array())
	{
		$files = $this->files->files($this->path);

		$sessions = array();

		foreach ($files as $file)
		{
			if (!$file->isFile())
			{
				continue;
			}

			$session = new Object;
			$session->session_id = $file->getName();
			$session->data       = $this->files->get($file->getPathname());

			$sessions[] = $session;
		}

		return $sessions;
	}
147823
public function query(array $stream, array $filters = [])
    {
        $qb = QueryBuilder::create((array)$stream);

        foreach ($filters as $key => $value) {
            $qb->addCriterion($key, $value);
        }

        $qb->sortedBy('occurred_on', 'ASC');

        return $qb->getResults();
    }
527886
public function applyFilters($filters)
    {
        foreach ($filters as $key => $value) {
            $this->filters[$key] = $value;
        }

        return $this;
    }
911964
protected function _parseFilters(array $filters) {
        $out = array();
        foreach ($filters as $key => $value) {
            // The deprecated way
            if (is_string($key) && is_array($value)) {
                $out[$key] = new Garp_Browsebox_Filter_Where($key, $value);
            } elseif ($value instanceof Garp_Browsebox_Filter_Abstract) {
                $out[$value->getId()] = $value;
            } else {
                throw new Garp_Browsebox_Exception('Invalid filter configuration encountered. Please use instances of Garp_Browsebox_Filter_Abstract to add filters.');
            }
        }
        return $out;
    }
1041358
public function setFilters(array $filters = [])
    {
        foreach ($filters as $filterName => $filterValue) {
            $this->addFilter($filterName, $filterValue);
        }

        return $this;
    }