RequestDataCollector.php

Go to the documentation of this file.

<?php
 
namespace ILIAS\TestQuestionPool;
 
use GuzzleHttp\Psr7\UploadedFile;
use ILIAS\FileUpload\DTO\UploadResult;
use ILIAS\Refinery\Transformation;
use ILIAS\Repository\BaseGUIRequest;
use ILIAS\Refinery\ConstraintViolationException;
use ILIAS\HTTP\Services;
use ILIAS\Refinery\Factory;
use ILIAS\FileUpload\FileUpload;
use Psr\Http\Message\ServerRequestInterface;
 
class RequestDataCollector implements RequestDataCollectorInterface
{
    use BaseGUIRequest;
 
    public function __construct(
        Services $http,
        Factory $refinery,
        protected readonly FileUpload $upload
    ) {
        $this->initRequest($http, $refinery);
    }
 
    public function getRequest(): ServerRequestInterface
    {
        return $this->http->request();
    }
 
    public function getProcessedUploads(): array
    {
        $uploads = [];
 
        if ($this->upload->hasUploads()) {
            if (!$this->upload->hasBeenProcessed()) {
                $this->upload->process();
            }
            $uploads = $this->upload->getResults();
        }
 
        return $uploads;
    }
 
    public function getUploadFilename(array $http_names, int $index): ?string
    {
        $uploaded_files = $this->http->request()->getUploadedFiles();
 
        while (($current_key = array_shift($http_names)) !== null) {
            if (!isset($uploaded_files[$current_key])) {
                return null;
            }
 
            $uploaded_files = $uploaded_files[$current_key];
 
            if (isset($uploaded_files[$index]) && $http_names === []) {
                $file = $uploaded_files[$index];
                $c = \Closure::bind(static function (UploadedFile $file): ?string {
                    return $file->file ?? null;
                }, null, $file);
 
                return $c($file);
            }
        }
 
        return null;
    }
 
    public function upload(): FileUpload
    {
        return $this->upload;
    }
 
    public function isset(string $key): bool
    {
        return $this->raw($key) !== null;
    }
 
    public function hasRefId(): bool
    {
        return $this->raw('ref_id') !== null;
    }
 
    public function getRefId(): int
    {
        return $this->int('ref_id');
    }
 
    public function hasQuestionId(): bool
    {
        return $this->raw('q_id') !== null;
    }
 
    public function getQuestionId(): int
    {
        return $this->int('q_id');
    }
 
    public function getIds(): array
    {
        return $this->strArray('id');
    }
 
    public function raw(string $key): mixed
    {
        return $this->get($key, $this->refinery->identity());
    }
 
    public function float(string $key): float
    {
        try {
            return $this->get($key, $this->refinery->kindlyTo()->float()) ?? 0.0;
        } catch (ConstraintViolationException $e) {
            return 0.0;
        }
    }
 
    public function string(string $key): string
    {
        return $this->get($key, $this->refinery->kindlyTo()->string()) ?? '';
    }
 
    public function bool(string $key): ?bool
    {
        return $this->get($key, $this->refinery->kindlyTo()->bool());
    }
 
    public function getParsedBody(): object|array|null
    {
        return $this->http->request()->getParsedBody();
    }
 
    public function getUnitIds(): array
    {
        return $this->intArray('unit_ids');
    }
 
    public function getUnitCategoryIds(): array
    {
        return $this->intArray('category_ids');
    }
 
    public function getMatchingPairs(): array
    {
        if (!$this->http->wrapper()->post()->has('matching')) {
            return [];
        }
 
        return $this->http->wrapper()->post()->retrieve(
            'matching',
            $this->refinery->byTrying([
                $this->refinery->container()->mapValues(
                    $this->refinery->custom()->transformation(
                        fn(string $v): array => $this->refinery->container()->mapValues(
                            $this->refinery->kindlyTo()->int()
                        )->transform(json_decode($v))
                    )
                ),
                $this->refinery->always([])
            ])
        );
    }
 
    public function getPostKeys(): array
    {
        return $this->http->wrapper()->post()->keys();
    }
 
    public function getCmdIndex(string $key): int|string|null
    {
        $cmd = $this->rawArray('cmd');
        if (!isset($cmd[$key]) || !is_array($cmd[$key])) {
            return null;
        }
        return key($cmd[$key]);
    }
 
    public function strArray(string $key, int $depth = 1): array
    {
        return $this->retrieveArray($key, $depth, $this->refinery->kindlyTo()->string());
    }
 
    public function floatArray(string $key): array
    {
        return $this->retrieveArray($key, 1, $this->refinery->kindlyTo()->float());
    }
 
    public function intArray(string $key): array
    {
        return $this->retrieveArray($key, 1, $this->refinery->kindlyTo()->int());
    }
 
    public function rawArray(string $key): array
    {
        return $this->retrieveArray($key, 1, $this->refinery->identity());
    }
 
    public function getRowIdParameter(string $key): string|int
    {
        return $this->get($key, $this->refinery->byTrying([
            $this->refinery->kindlyTo()->int(),
            $this->refinery->kindlyTo()->string(),
            $this->refinery->custom()->transformation(fn(array $v): string|int => $v[0])
        ]));
    }
 
    public function getMultiSelectionIds(string $key): array|string
    {
        $query = $this->http->wrapper()->query();
 
        if (!$query->has($key)) {
            return [];
        }
 
        return $query->retrieve(
            $key,
            $this->refinery->custom()->transformation(
                static fn(array|string $value): array|string => $value === 'ALL_OBJECTS' || $value[0] === 'ALL_OBJECTS'
                    ? 'ALL_OBJECTS'
                    : array_map('intval', $value)
            )
        );
    }
 
    private function retrieveArray(string $key, int $depth, Transformation $transformation): array
    {
        $chain = $this->refinery->kindlyTo()->dictOf($transformation);
        for ($i = 1; $i < $depth; $i++) {
            $chain = $this->refinery->kindlyTo()->dictOf($chain);
        }
 
        return $this->get(
            $key,
            $this->refinery->byTrying([
                $chain,
                $this->refinery->always([])
            ])
        ) ?? [];
    }
}