POData\Writers\ResponseWriter

Complexity

Total Complexity

10

Size/Duplication

Total Lines	67
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	4
Bugs	0	Features	0

1 Method

Rating	Name	Duplication	Size	Complexity
B	write()	0	56	10

<?php

namespace POData\Writers;

use POData\Common\HttpStatus;
use POData\Common\ODataConstants;
use POData\Common\MimeTypes;
use POData\IService;
use POData\UriProcessor\RequestDescription;
use POData\UriProcessor\ResourcePathProcessor\SegmentParser\TargetKind;
use POData\Writers\Metadata\MetadataWriter;




/**
 * Class ResponseWriter
 * @package POData\Writers
 */
class ResponseWriter
{
    /**
     * Write in specific format
     *
     * @param IService $service
     * @param RequestDescription $request the OData request
     * @param mixed $entityModel OData model instance
     * @param String $responseContentType Content type of the response
     *
     */
    public static function write(
        IService $service,
        RequestDescription $request,
        $entityModel,
        $responseContentType
    ) {
        $responseBody = null;
        $dataServiceVersion = $request->getResponseVersion();
        $targetKind = $request->getTargetKind();

        if ($targetKind == TargetKind::METADATA) {
            // /$metadata
            $writer = new MetadataWriter($service->getProvidersWrapper());
            $responseBody = $writer->writeMetadata();
            $dataServiceVersion = $writer->getDataServiceVersion();
        } else if ($targetKind == TargetKind::PRIMITIVE_VALUE && $responseContentType != MimeTypes::MIME_APPLICATION_OCTETSTREAM) {
            //This second part is to exclude binary properties
            // /Customer('ALFKI')/CompanyName/$value
            // /Customers/$count
            $responseBody = mb_convert_encoding($request->getTargetResult(), 'UTF-8');
        } else if ($responseContentType == MimeTypes::MIME_APPLICATION_OCTETSTREAM || $targetKind == TargetKind::MEDIA_RESOURCE) {
            // Binary property or media resource
            if ($request->getTargetKind() == TargetKind::MEDIA_RESOURCE) {
                $result = $request->getTargetResult();
                $streamInfo = $request->getResourceStreamInfo();
                $provider = $service->getStreamProviderWrapper();
                $eTag = $provider->getStreamETag($result, $streamInfo);

It seems like $result can also be of type array and array; however, parameter $entity of POData\Providers\Stream\StreamProviderWrapper::getStreamETag() does only seem to accept object, maybe add an additional type check?

                $service->getHost()->setResponseETag($eTag);
                $responseBody = $provider->getReadStream($result, $streamInfo);

It seems like $result can also be of type array and array; however, parameter $entity of POData\Providers\Stream\StreamProviderWrapper::getReadStream() does only seem to accept object, maybe add an additional type check?

            } else {
                $responseBody = $request->getTargetResult();
            }

            if (is_null($responseContentType)) {

The condition is_null($responseContentType) is always false.

                $responseContentType = MimeTypes::MIME_APPLICATION_OCTETSTREAM;
            }
        } else {
            $writer = $service->getODataWriterRegistry()->getWriter($request->getResponseVersion(), $responseContentType);
            $writer->clear();

The method clear() does not exist on POData\Writers\IODataWriter. Since it exists in all sub-types, consider adding an abstract or default implementation to POData\Writers\IODataWriter.

            //TODO: move ot Messages
            if (is_null($writer)) {
                throw new \Exception("no writer can handle the request");
            }

            if (is_null($entityModel)) {  //TODO: this seems like a weird way to know that the request is for a service document..i'd think we know this some other way
                $responseBody = $writer->writeServiceDocument($service->getProvidersWrapper())->getOutput();
            } else {
                $responseBody = $writer->write($entityModel)->getOutput();
            }
        }

        $service->getHost()->setResponseStatusCode(HttpStatus::CODE_OK);
        $service->getHost()->setResponseContentType($responseContentType);
        $service->getHost()->setResponseVersion($dataServiceVersion->toString() . ';');
        $service->getHost()->setResponseCacheControl(ODataConstants::HTTPRESPONSE_HEADER_CACHECONTROL_NOCACHE);
        $service->getHost()->getOperationContext()->outgoingResponse()->setStream($responseBody);

It seems like $responseBody can also be of type array and array and array; however, parameter $value of POData\OperationContext\Web\OutgoingResponse::setStream() does only seem to accept string, maybe add an additional type check?

    }
}