App\Middleware\RenderDataStream

Complexity

Total Complexity

8

Size/Duplication

Total Lines	48
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	process()	0	14	2
A	getConverter()	0	3	1
A	__construct()	0	4	1
A	convertData()	0	4	1
A	getRelevantType()	0	4	1
A	addHeaders()	0	6	2

<?php

declare(strict_types=1);

namespace App\Middleware;

use App\Stream\Data\Converter;
use App\Stream\Data\PrintRConverter;
use App\Stream\DataStream;
use App\Stream\Value\DataResponseProvider;
use Psr\Container\ContainerInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\StreamFactoryInterface;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;

final class RenderDataStream implements MiddlewareInterface
{
    private ContainerInterface $container;
    private StreamFactoryInterface $streamFactory;

    public function __construct(ContainerInterface $container, StreamFactoryInterface $streamFactory)
    {
        $this->container = $container;
        $this->streamFactory = $streamFactory;
    }

    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        $response = $handler->handle($request);
        $stream = $response->getBody();
        if (!$stream instanceof DataStream) {
            return $response;
        }

        $data = $stream->getData();
        $converter = $this->getConverter($data->getFormat(), $request);

        $response = $response->withBody($this->convertData($data, $converter));

        return $this->addHeaders($response->withHeader('Content-Type', $converter::getFormat()), $data->getHeaders());
    }

    private function addHeaders(ResponseInterface $response, array $headers): ResponseInterface
    {
        foreach ($headers as $header => $value) {
            $response = $response->withHeader($header, $value);
        }
        return $response;
    }
    private function convertData(DataResponseProvider $data, Converter $converter): StreamInterface
    {
        $result = $converter->convert($data->getData(), $data->getParams());
        return $this->streamFactory->createStream($result);
    }

    private function getRelevantType(ServerRequestInterface $request): string

The parameter $request is not used and could be removed.

    {
        # todo
        return PrintRConverter::class;
    }
    private function getConverter(?string $format, ServerRequestInterface $request): Converter
    {
        return $this->container->get($format ?? $this->getRelevantType($request));
    }
}