Get all Request values from all fields, and nothing else.

@param bool $with_nulls
@return array
165553
public function getFieldValues($with_nulls = true)
    {
        $request_values = $this->getRequest()->all();

        $values = [];
        foreach ($this->getAllAttributes() as $attribute) {
            $value = Arr::get($request_values, $attribute);
            if ($with_nulls || $value !== null) {
                Arr::set($values, $attribute, $value);
            }
        }

        // If this form is a child form, cherry pick a part
        if ($prefix = $this->getName()) {
            $prefix = $this->formHelper->transformToDotSyntax($prefix);
            $values = Arr::get($values, $prefix);
        }

        // Allow form-specific value alters
        $this->formHelper->alterFieldValues($this, $values);

        return $values;
    }
1269318
public function allValues()
    {
        $raw = $this->_parameters['_raw'];
        $values = explode(',', $raw);
        $result = ArrayMethods::trim($values);
        return $result;
    }
857171
protected function getValues()
    {
        $uri = uri();
        $key = $this->session->has($uri) ? $uri : request()->path();

        $params = $this->session->get($key . '.' . get_called_class());
        if (is_null($params) or ! isset($params['column']) or ! $params['column'] == $this->column) {
            return [];
        }
        if (!isset($params['value'])) {
            return [];
        }
        if (empty((array) $params['value'])) {
            $params = $this->session->get($uri);
            unset($params[get_called_class()]);
            $this->session->put($key, $params);
            $this->session->save();
        } else {
            return $params['value'];
        }
        return [];
    }
1299887
private static function _loadNullValues()
    {
        $values = array();
        $cls    = get_called_class();

        if (!array_key_exists($cls, self::$_columns)) {
            return null;
        }

        foreach (self::$_columns[$cls] as $column) {
            $name = self::isIgnoringCase() ? strtolower($column) : $column;
            $values[$column] = null;
        }
        return $values;
    }
1082242
public function getParametersWithValue($requestValues)
    {
        // Final request parameters array
        $parameters = array();

        // Setting parameters
        foreach ($this->parameters as $paramKey => $paramDefaultValue) {
            // Overriding parameter value with the given one
            if (isset($requestValues[$paramKey]) && !empty($requestValues[$paramKey])) {
                $parameters[$paramKey] = $requestValues[$paramKey];
            } elseif (!empty($paramDefaultValue)) {
                $parameters[$paramKey] = $paramDefaultValue;
            }
        }

        // Returning populated array
        return $parameters;
    }
541677
protected function getRequiredUseClasses(array $fields, $withAuth)
    {
        $commands = [];
        if ($withAuth) {
            $commands[] = $this->getUseClassCommand('Auth');
        }

        foreach ($fields as $field) {
            // Extract the name spaces fromt he custom rules
            $customRules = $this->extractCustomValidationRules($field->getValidationRule());
            $namespaces = $this->extractCustomValidationNamespaces($customRules);
            foreach ($namespaces as $namespace) {
                $commands[] = $this->getUseClassCommand($namespace);
            }
        }

        usort($commands, function ($a, $b) {
            return strlen($a) - strlen($b);
        });

        return implode(PHP_EOL, array_unique($commands));
    }
135991
public function findAll($columns = ['*'], $with = [])
    {
        $cacheKey = $this->generateKey([$columns, $with]);

        return $this->cacheResults(get_called_class(), __FUNCTION__, $cacheKey, function () use ($columns, $with) {
            return $this->model->with($with)
                ->get($columns);
        });
    }
1290823
private function fetchLoadValues(): bool
    {
        $row = $this->result()->fetchRow();
        if (false === $row) {
            $this->originalValues = null;
            $this->values = [];
            return false;
        }
        $this->originalValues = $this->setValuesFromDatafields($row);
        $this->values = $this->originalValues;
        return true;
    }
532871
public function getParams($withActionParams = false)
    {
        return $withActionParams ? array_merge($this->actionParams, $this->params) : $this->params;
    }
769110
public function params($requestParams): array
    {
        // apply type and default value for request params
        $params = [];
        foreach ($this->params as $param => $type) {
            if (isset($requestParams[$param])) {
                switch ($type) {
                    case 'bool':
                    case 'boolean':
                        $params[] = (bool)$requestParams[$param];
                        break;
                    case 'int':
                    case 'integer':
                        $params[] = (int)$requestParams[$param];
                        break;
                    case 'float':
                        $params[] = (float)$requestParams[$param];
                        break;
                    case 'string':
                        $params[] = (string)$requestParams[$param];
                        break;
                    case 'array':
                        $params[] = (array)$requestParams[$param];
                        break;
                    default:
                        $params[] = $requestParams[$param];
                        break;
                }
            } elseif (isset($this->values[$param])) {
                $params[] = $this->values[$param];
            } else {
                $params[] = null;
            }
        }
        return $params;
    }
976112
function data($items = null): array
    {
        $this->putRetainedFilterValuesInSession();

        $items = $items ?: $this->getListData(
            EntityListQueryParams::create()
                ->setDefaultSort($this->defaultSort, $this->defaultSortDir)
                ->fillWithRequest()
                ->setDefaultFilters($this->getFilterDefaultValues())
        );

        if($items instanceof LengthAwarePaginator) {
            $page = $items->currentPage();
            $totalCount = $items->total();
            $pageSize = $items->perPage();
            $items = $items->items();
        }

        $this->addInstanceCommandsAuthorizationsToConfigForItems($items);

        $keys = $this->getDataKeys();

        return [
            "items" =>
                collect($items)
                    ->map(function($row) use($keys) {
                        // Filter model attributes on actual form fields
                        return collect($row)->only(
                            array_merge(
                                $this->entityStateAttribute ? [$this->entityStateAttribute] : [],
                                $this->multiformAttribute ? [$this->multiformAttribute] : [],
                                [$this->instanceIdAttribute],
                                $keys
                            )
                        )->all();
                    })->all()
        ] + (isset($page) ? compact('page', 'totalCount', 'pageSize') : []);
    }
340797
public function allFiltered($columns = [], array $with = [])
    {
        $params = request()->all();
        $data = $this->with($with)->select($columns);

        $orderBy = $params['orderBy'] ?? null;
        $query = $params['query'] ?? null;
        $limit = $params['limit'] ?? null;
        $page = $params['page'] ?? 1;
        $ascending = $params['ascending'] ?? 1;
        $byColumn = $params['byColumn'] ?? 0;

        if ($query !== null) {
            $data = $byColumn == 1 ? $this->filterByColumn($data, $query) :
                                     $this->filter($data, $query, $columns);
        }

        $count = $data->count();

        if ($limit !== null) {
            $data->limit($limit)->skip($limit * ($page - 1));
        }
        if ($orderBy !== null) {
            $orderBy .= $this->translatableOperator($orderBy);
            $direction = $ascending == 1 ? 'ASC' : 'DESC';
            $data->orderBy($orderBy, $direction);
        }

        $results = $data->get()
            ->translate(config('typicms.content_locale'));

        return [
            'data' => $results,
            'count' => $count,
        ];
    }
1336516
public function getParents($withSelf = TRUE) {
    $node = $this;
    $parents = array();
    while ($node->getParent() != NULL) {
      $parents[] = $node->getParent();
      $node = $node->getParent();
    }
    if ($withSelf) array_unshift($parents,$this);
    return $parents;
  }
1099996
public function getValueWithMultipleWhere($wheres = '', $field = 'id', $fieldOutput = '')
    {
        if (!is_array($fieldOutput)) {
            $fieldOutput = [$fieldOutput];
        }
        $db = $this->db->select($fieldOutput)->from($this->table);
        if (is_array($wheres) && count($wheres) > 0) {
            foreach ($wheres as $key => $value) {
                if (is_array($value['value'])) {
                    $db->whereIn($value['field'], $value['value']);
                } else {
                    $db->where($value['field'], $value['operator'], $value['value']);
                }
            }
        } else {
            $db->where($field, self::OPERATOR_EQUAL_TO, $wheres);
        }
        $result = $db->execute()->fetch();

        $this->debug->debug(__FUNCTION__, 'GET Result => ' . json_encode($result));
        if (isset($result->$fieldOutput)) {
            return $result->$fieldOutput;
        } else {
            return NULL;
        }
    }
1315152
public function getData(array $whitelist = null)
    {
        $data = [];
        if ($whitelist !== null) {
            $whitelist = array_flip($whitelist);
        }
        $reflection = $this->getCurrentReflection();
        $usedGetters = [];
        foreach ($reflection->getEntityProperties() as $property) {
            $field = $property->getName();
            if ($whitelist !== null and !isset($whitelist[$field])) {
                continue;
            }
            $data[$field] = $this->__get($property->getName());
            $getter = $property->getGetter();
            if ($getter !== null) {
                $usedGetters[$getter] = true;
            }
        }
        foreach ($reflection->getGetters() as $name => $getter) {
            if (isset($usedGetters[$getter->getName()])) {
                continue;
            }
            $field = lcfirst(substr($name, 3));
            if ($whitelist !== null and !isset($whitelist[$field])) {
                continue;
            }
            if ($getter->getNumberOfRequiredParameters() === 0) {
                $data[$field] = $getter->invoke($this);
            }
        }
        return $data;
    }
510652
protected function getFields(): ?array
    {
        $fields = $this->requestStack->getCurrentRequest()->get('fields');

        if (!is_null($fields)) {
            $fields = array_map('trim', explode(',', $fields));
        }

        return $fields;
    }
1123142
public static function values($withEmpty = false)
    {
        $values = parent::values($withEmpty);

        // Correct some display values
        $values[static::LINKEDIN] = 'LinkedIn';

        return $values;
    }