POData\BaseService::getResponseContentType()

Complexity

Conditions	16
Paths	60

Size

Total Lines	108
Code Lines	58

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	0

<?php
    public function getResponseContentType(
        RequestDescription $request,
        IUriProcessor $uriProcessor
    ): ?string {
        $baseMimeTypes = [
            MimeTypes::MIME_APPLICATION_JSON,
            MimeTypes::MIME_APPLICATION_JSON_FULL_META,
            MimeTypes::MIME_APPLICATION_JSON_NO_META,
            MimeTypes::MIME_APPLICATION_JSON_MINIMAL_META,
            MimeTypes::MIME_APPLICATION_JSON_VERBOSE,];

        // The Accept request-header field specifies media types which are acceptable for the response

        $host              = $this->getHost();
        $requestAcceptText = $host->getRequestAccept();
        $requestVersion    = $request->getResponseVersion();

        //if the $format header is present it overrides the accepts header
        $format = $host->getQueryStringItem(ODataConstants::HTTPQUERY_STRING_FORMAT);
        if (null !== $format) {
            //There's a strange edge case..if application/json is supplied and it's V3
            if (MimeTypes::MIME_APPLICATION_JSON == $format && Version::v3() == $requestVersion) {
                //then it's actual minimalmetadata
                //TODO: should this be done with the header text too?
                $format = MimeTypes::MIME_APPLICATION_JSON_MINIMAL_META;
            }

            $requestAcceptText = ServiceHost::translateFormatToMime($requestVersion, $format);
        }

        //The response format can be dictated by the target resource kind. IE a $value will be different then expected
        //getTargetKind doesn't deal with link resources directly and this can change things
        $targetKind = $request->isLinkUri() ? TargetKind::LINK() : $request->getTargetKind();

        $availableMimeTypesByTarget = [
            TargetKind::METADATA()->getValue()          => [MimeTypes::MIME_APPLICATION_XML],
            TargetKind::SERVICE_DIRECTORY()->getValue() => array_merge([MimeTypes::MIME_APPLICATION_ATOMSERVICE], $baseMimeTypes),
            TargetKind::PRIMITIVE()->getValue()              => array_merge([MimeTypes::MIME_APPLICATION_XML, MimeTypes::MIME_TEXTXML,], $baseMimeTypes),
            TargetKind::COMPLEX_OBJECT()->getValue()              => array_merge([MimeTypes::MIME_APPLICATION_XML, MimeTypes::MIME_TEXTXML,], $baseMimeTypes),
            TargetKind::BAG()->getValue()              => array_merge([MimeTypes::MIME_APPLICATION_XML, MimeTypes::MIME_TEXTXML,], $baseMimeTypes),
            TargetKind::LINK()->getValue()              => array_merge([MimeTypes::MIME_APPLICATION_XML, MimeTypes::MIME_TEXTXML,], $baseMimeTypes),
            TargetKind::SINGLETON()->getValue()          => array_merge([MimeTypes::MIME_APPLICATION_ATOM], $baseMimeTypes),
            TargetKind::RESOURCE()->getValue()          => array_merge([MimeTypes::MIME_APPLICATION_ATOM], $baseMimeTypes),
        ];

        if($targetKind && array_key_exists($targetKind->getValue(),$availableMimeTypesByTarget)){
            return HttpProcessUtility::selectMimeType($requestAcceptText, $availableMimeTypesByTarget[$targetKind->getValue()]);

        }
        switch ($targetKind) {
            case TargetKind::PRIMITIVE_VALUE():
                $supportedResponseMimeTypes = [MimeTypes::MIME_TEXTPLAIN];

                if ('$count' != $request->getIdentifier()) {
                    $projectedProperty = $request->getProjectedProperty();
                    if (null === $projectedProperty) {
                        throw new InvalidOperationException('is_null($projectedProperty)');
                    }
                    $type = $projectedProperty->getInstanceType();
                    if (!$type instanceof IType) {
                        throw new InvalidOperationException('!$type instanceof IType');
                    }
                    if ($type instanceof Binary) {
                        $supportedResponseMimeTypes = [MimeTypes::MIME_APPLICATION_OCTETSTREAM];
                    }
                }

                return HttpProcessUtility::selectMimeType(
                    $requestAcceptText,
                    $supportedResponseMimeTypes
                );


            case TargetKind::MEDIA_RESOURCE():
                if (!$request->isNamedStream() && true !== $request->getTargetResourceType()->isMediaLinkEntry()) {
                    throw ODataException::createBadRequestError(
                        Messages::badRequestInvalidUriForMediaResource(
                            $host->getAbsoluteRequestUri()->getUrlAsString()
                        )
                    );
                }

                $uriProcessor->execute();
                $request->setExecuted();
                // DSSW::getStreamContentType can throw error in 2 cases
                // 1. If the required stream implementation not found
                // 2. If IDSSP::getStreamContentType returns NULL for MLE
                $responseContentType = $this->getStreamProviderWrapper()
                    ->getStreamContentType(
                        $request->getTargetResult(),
                        $request->getResourceStreamInfo()
                    );

                // Note StreamWrapper::getStreamContentType can return NULL if the requested named stream has not
                // yet been uploaded. But for an MLE if IDSSP::getStreamContentType returns NULL
                // then StreamWrapper will throw error
                if (null !== $responseContentType) {

The condition null !== $responseContentType is always true.

                    $responseContentType = HttpProcessUtility::selectMimeType(
                        $requestAcceptText,
                        [$responseContentType]
                    );
                }

                return $responseContentType;
        }

        //If we got here, we just don't know what it is...
        throw new ODataException(Messages::unsupportedMediaType(), 415);
    }