Returns an array with all data which should be displayed on this page

@access public
@param \Zepi\DataSource\Core\Entity\DataRequest $request
@return array
774293
public function getData(DataRequest $request)
    {
        $userManager = $this->framework->getInstance('\\Zepi\\Web\\AccessControl\\Manager\\UserManager');
        $users = $userManager->find($request);
        
        return $users;
    }
1310244
protected function getIds( $request )
	{
		$ids = [];

		if( isset( $request->data ) )
		{
			foreach( (array) $request->data as $entry )
			{
				if( isset( $entry->id ) ) {
					$ids[] = $entry->id;
				}
			}
		}

		return $ids;
	}
1095177
protected function getData(Request $request, $fallback = true)
    {
        $data = $request->request->all();
        $data['locale'] = $request->get('locale', $fallback ? $this->getLocale($request) : null);
        $data['collection'] = $request->get('collection');
        $data['contentLanguages'] = $request->get('contentLanguages', []);
        $data['publishLanguages'] = $request->get('publishLanguages', []);
        $data['title'] = $request->get('title', $fallback ? $this->getTitleFromUpload($request) : null);
        $data['formats'] = $request->get('formats', []);

        return $data;
    }
295307
private function getParsedBody(Request $request): array
    {
        $contentType = \explode(';', (string) $request->headers->get('content-type'), 2)[0];

        // JSON object
        switch ($contentType) {
            case static::CONTENT_TYPE_JSON:
                $parsedBody = \json_decode($request->getContent(), true);

                if (\JSON_ERROR_NONE !== \json_last_error()) {
                    throw new BadRequestHttpException('POST body sent invalid JSON');
                }
                break;

            case static::CONTENT_TYPE_FORM_DATA:
                $parsedBody = $this->handleUploadedFiles($request->request->all(), $request->files->all());
                break;

            default:
                throw new BadRequestHttpException(\sprintf(
                    'Batching parser only accepts "%s" or "%s" content-type but got %s.',
                    static::CONTENT_TYPE_JSON,
                    static::CONTENT_TYPE_FORM_DATA,
                    \json_encode($contentType)
                ));
        }

        return $parsedBody;
    }
1310706
public function cgetAction(Request $request)
    {
        $ids = array_filter(explode(',', $request->get('ids', '')));

        $result = $this->getCustomerManager()->findByIds($ids);

        $list = new CollectionRepresentation(
            $result,
            self::$entityKey
        );
        $view = $this->view($list, 200);

        return $this->handleView($view);
    }
411811
private function getListRepresentation($request)
    {
        /** @var RestHelperInterface $restHelper */
        $restHelper = $this->get('sulu_core.doctrine_rest_helper');
        $locale = $this->getRequestParameter($request, 'locale', true);
        $fieldDescriptors = $this->getManager()->getListFieldDescriptors($locale);

        /** @var DoctrineListBuilderFactory $factory */
        $factory = $this->get('sulu_core.doctrine_list_builder_factory');
        $listBuilder = $factory->create(self::$entityName);
        $restHelper->initializeListBuilder(
            $listBuilder,
            $fieldDescriptors
        );

        if ($request->get('context')) {
            $listBuilder->where($fieldDescriptors['context'], $request->get('context'));
        }

        // return all filters created by the user or without user
        $userCondition = [$this->getUser()->getId(), null];
        $listBuilder->in($fieldDescriptors['user'], $userCondition);

        $list = new ListRepresentation(
            $listBuilder->execute(),
            self::$entityKey,
            'get_filters',
            $request->query->all(),
            $listBuilder->getCurrentPage(),
            $listBuilder->getLimit(),
            $listBuilder->count()
        );

        return $list;
    }
388711
public function cgetAction(Request $request)
    {
        $ids = array_map(
            function($item) {
                $parts = explode(';', $item);

                return ['type' => $parts[0], 'id' => $parts[1]];
            },
            array_filter(explode(',', $request->get('ids', '')))
        );

        return $this->handleView(
            $this->view(
                new CollectionRepresentation(
                    $this->get('sulu_page.teaser.manager')->find($ids, $this->getLocale($request)),
                    'teasers'
                )
            )
        );
    }
231823
public function index(TaskRequest $request)
    {

        if ($this->response->typeIs('json')) {
            $pageLimit = $request->input('pageLimit');
            $data      = $this->repository
                ->setPresenter(\Litepie\Task\Repositories\Presenter\TaskListPresenter::class)
                ->getDataTable($pageLimit);
            return $this->response
                ->data($data)
                ->output();
        }

        $tasks = $this->repository->paginate();

        return $this->response->title(trans('task::task.names'))
            ->view('task::task.index', true)
            ->data(compact('tasks'))
            ->output();
    }
714582
public function toArray($request)
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'identifier' => $this->identifier,
            'data_type' => $this->data_type,
            'field_type' => $this->field_type,
            'sort_order' => $this->sort_order,
            'dropdown_options' => $this->when($this->field_type == 'SELECT', new PropertyDropdownOptionCollectionResource($this->propertyDropdownOptions)),
            'use_for_all_products' => $this->use_for_all_products,
            'created_at' => $this->created_at,
            'updated_at' => $this->updated_at,
        ];
    }
858349
public function countData(DataRequest $request)
    {
        $userManager = $this->framework->getInstance('\\Zepi\\Web\\AccessControl\\Manager\\UserManager');
        $numberOfUsers = $userManager->count($request);
        
        return $numberOfUsers;
    }
498035
public function toArray($request)
    {
        return [
            'id'           => (int) $this->id,
            'author_id'    => $this->author_id,
            'type'         => $this->whenLoaded('type', function () {
                return $this->type->name;
            }),
            'region'       => $this->region,
            'theme'        => $this->theme,
            'weight'       => $this->weight,
            'filter'       => $this->filter,
            'options'      => $this->options,
            'is_active'    => $this->is_active,
            'is_cacheable' => $this->is_cacheable,
            'created_at'   => $this->created_at->toIso8601String(),
            'updated_at'   => $this->updated_at->toIso8601String(),
            'translations' => BlockTranslation::collection($this->whenLoaded('translations')),
        ];
    }
1130410
public function extractData(Request $request)
    {
        $data = $request->data();
        $entityData = array();
        $inputName = $this->getInputName();

        if (!array_key_exists($inputName, $data)) {
            return array();
        }

        $entityData = $data[$inputName];
        $filteredData = array();

        foreach ($this->getAttributeNames() as $key) {
            if (array_key_exists($key, $entityData)) {
                $filteredData[$key] = $entityData[$key];
            }
        }

        return $filteredData;
    }
1305040
public static function getData(Request $request, DataSourceInterface $source, $prefix = '')
    {
        $source->setPageSize((int) ($request->get($prefix.'ps', $source->getPageSize())));
        $source->setPageNumber((int) ($request->get($prefix.'pn', $source->getPageNumber())));
        $source->setSortColumns((array) $request->get($prefix.'sc', []));
        $source->setParameters((array) $request->get($prefix.'p', []));

        return [
            'rows' => $source->getRows(),
            'size' => $source->getSize(),
            'pageSize' => $source->getPageSize(),
            'pageNumber' => $source->getPageNumber(),
            'pageCount' => $source->getPageCount(),
            'sortColumns' => $source->getSortColumns(),
        ];
    }
624849
public function listAction(Request $request)
    {
        $dataGrid = $this->getDataGrid();

        $this->bindDataGridRequest($dataGrid, $request);

        return $this->renderAction(
            array_merge(
                $this->getViewParameters($request),
                ['datagrid' => $dataGrid]
            )
        );
    }
823829
private function getEmailDatas($request, $e)
    {
        $session = $request->session()->all();
        return [
            'date'          => Carbon::now()->format('d.m.Y H:i:s'),
            'rUser'         => $request->user(),
            'rSessionOld'   => isset($session['flash']) ? $session['flash']['old'] : [],
            'rSessionNew'   => isset($session['flash']) ? $session['flash']['new'] : [],
            'rAll'          => $request->all(),
            'rIp'           => $request->ip(),
            'rDecodedPath'  => $request->decodedPath(),
            'rPath'         => $request->path(),
            'rFullUrl'      => $request->fullUrl(),
            'rUrl'          => $request->url(),
            'rRoot'         => $request->root(),
            'rMethod'       => $request->method(),
            'eMessage'      => method_exists($e, 'getMessage') ? $e->getMessage() : '',
            'eCode'         => method_exists($e, 'getStatusCode') ? $e->getStatusCode() : 200,
            'eFile'         => method_exists($e, 'getFile') ? $e->getFile() : '',
            'eLine'         => method_exists($e, 'getLine') ? $e->getLine() : '',
            'ePrevious'     => is_string($e->getPrevious()) ? $e->getPrevious() : '',
            'eTrace'        => nl2br($e->getTraceAsString()),
        ];
    }
799386
private function getValuesFromRequest(Request $request)
    {
        $values = array_merge($request->query->all(), $request->request->all());
        $contentValues = json_decode($request->getContent(), true);
        if (is_array($contentValues)) {
            $values = array_merge($values, $contentValues);
        }

        return $values;
    }
1010281
public function getSearchCharacterAssetsData(Request $request)
    {

        $assets = $this->doSearchCharacterAssets();

        return DataTables::of($assets)
            ->editColumn('characterName', function ($row) {

                $character = CharacterInfo::find($row->character_id) ?: $row->character_id;

                return view('web::partials.character', compact('character'));
            })
            ->editColumn('typeName', function ($row) {

                return view('web::search.partials.typename', compact('row'));
            })
            ->rawColumns(['characterName', 'typeName'])
            ->make(true);

    }