Get the users database information based on a filter.

@param IteratorFilter $filter Filter to find user
@return UserModel[]
@throws \ByJG\MicroOrm\Exception\InvalidArgumentException
@throws \ByJG\Serializer\Exception\InvalidArgumentException
979438
public function getIterator(IteratorFilter $filter = null)
    {
        if (is_null($filter)) {
            $filter = new IteratorFilter();
        }

        $param = [];
        $formatter = new IteratorFilterSqlFormatter();
        $sql = $formatter->getFilter($filter->getRawFilters(), $param);

        $query = Query::getInstance()
            ->table($this->getUserDefinition()->table())
            ->where($sql, $param);

        return $this->userRepository->getByQuery($query);
    }
606587
public function getEAVAttributes(FilterInterface $filter): array
    {
        return $this->filterHelper->getEAVAttributes($this->getFamily(), $filter->getAttributes());
    }
1080021
public static function find(Filter ...$filters)
    {
        $modelClass = get_called_class();
        $collection = new RepositoryCollection($modelClass);
        $collection->filter(...$filters);
        return $collection;
    }
883981
public function getAll(array $filter)
    {
        $this->select = $this->readSql->select('history');
                    
        $this->joinAuth()->joinAclRole();
        
        $this->filter($filter)->sort($filter); 

        if (array_key_exists('pagination', $filter)) {
            if ($filter['pagination'] == 'off') {  
                return $this->getRows();    
            }
        }

        return $this->getPaginator();
    }
922886
public function getAll($filter = null)
    {
        $className = self::getEntitiesClassName();
        $results = $this->getDataSource()->retrieveAll($filter);

        // Convert the resulting data to entities.
        $entities = array();
        foreach ($results as $data) {
            $id = @$data['id'];
            $entity = $this->getEntity($id);
            if (empty($entity)) {
                $entity = new $className($data);
            }
            $entities[] = $entity;
        }

        return $entities;
    }
259360
public function findAll($re, $filter = null) {
        $result = array();
        $this->each(function($context) use ($re, $filter, &$result) {
            $context->findAll($re, $filter)->each(
                function($context) use (&$result) {
                    $result[] = $context;
                }
            );
        });

        return new self($result);
    }
521460
public function get_selected_users() {
        global $DB;
        $idlist = array();
        if (!empty($this->filters->userids)) {

            $idlist = explode(',', $this->filters->userids);
            list($where, $params) = $DB->get_in_or_equal($idlist);
            return $DB->get_records_select('user', "id $where", $params);

        }
        return $idlist;
    }
594272
public function filterResult(callable $filter)
    {
        $result = [];

        foreach ($this->files as $file) {
            if ($filter($file)) {
                $result[] = $file;
            }
        }

        return $result;
    }
33073
protected function getFilterParams(array &$filters, $filter)
    {
        $fragments = preg_split('%;%', $filter, -1, PREG_SPLIT_NO_EMPTY);

        $name = array_shift($fragments);
        $params = [];

        foreach ($fragments as $param) {
            list($key, $value)  = explode('=', $param);
            $params[$key] = $value;
        }

        $filters[$name] = $params;
    }
366436
public function filter(/*Callable*/ $filter)
    {
        $result = clone $this;
        foreach ($this as $object)
        {
            if (call_user_func($filter, $object) === false) {
                $result->remove($object);
            }
        }

        return $result;
    }
836070
protected function getUserFunctionariesFilter(string $filter = null)
    {
        $mappingConfiguration = new PropertyMappingConfiguration();
        return $this->convertFunctionariesFilter($mappingConfiguration, $filter);
    }
1223308
public function iterator($filter = null){
        $ret = new Iterator($this, $this->vo);
        $ret->setCloneVo($this->toCloneVo);
        $this->setupIteratorRelations($ret);
        $ret->setRoot();

        if ($filter != null){
            $ret = new Filter($ret, $filter);
        }
        return $ret;
    }
741266
public function getFilteredOptions(string $filter) : array
    {
        $options = call_user_func($this->fieldOptionsLoader, $filter);
        return (new ArrayFieldOptions($options))->getAll();
    }
821703
private function getEntity($filter)
    {
        $roles = $this->getRepository('\erdiko\users\entities\Role');

        if (isset($filter['id']) && $filter['id'] > 0) {
            $result = $roles->find($filter['id']);
        } else {
            $result = new \erdiko\users\entities\Role();
        }
        return $result;
    }
1206272
public function getFilters()
    {
        // @todo build commong database filters for node datasource into some
        //   trait or abstract implemetnation to avoid duplicates
        return [
            (new Filter('status', $this->t("Published")))
                ->setChoicesMap([
                    1 => $this->t("Yes"),
                    0 => $this->t("No"),
                ]),
            (new Filter('promote', $this->t("Promoted to front page")))
                ->setChoicesMap([
                    1 => $this->t("Yes"),
                    0 => $this->t("No"),
                ]),
            (new Filter('sticky', $this->t("Sticky")))
                ->setChoicesMap([
                    1 => $this->t("Yes"),
                    0 => $this->t("No"),
                ]),
            (new Filter('type', $this->t("Type")))
                ->setChoicesMap(node_type_get_names()),
            (new Filter('history_user_id', $this->t("User (history)"))),
                /* ->setChoicesMap(node_type_get_names()), @todo use callback */
            (new Filter('revision_user_id', $this->t("User (node revision)"))),
                /* ->setChoicesMap(node_type_get_names()), @todo use callback */
            (new Filter('user_id', $this->t("User (node owner)"))),
                /* ->setChoicesMap(node_type_get_names()), @todo use callback */
        ];
    }
177351
public function getMethods($filter = \ReflectionProperty::IS_PUBLIC)
    {
        $methods = array();
        $reflectionMethods = $this->reflectionEntity->getMethods($filter);
        foreach ($reflectionMethods as $method) {
            $methods[] = new Method($method->name, $method->isStatic());
        }

        return $methods;
    }
576045
public static aaauser[] get_filtered(nitro_service service, String filter) throws Exception{
		aaauser obj = new aaauser();
		options option = new options();
		option.set_filter(filter);
		aaauser[] response = (aaauser[]) obj.getfiltered(service, option);
		return response;
	}