StreamProviderWrapper::_loadStreamProvider() - Code Metrics - Qeti/POData - Measure and Improve Code Quality continuously with Scrutinizer

StreamProviderWrapper::_loadStreamProvider() D
last analyzed 2017-02-19 06:57 UTC

↳ Parent: StreamProviderWrapper
Complexity

Conditions	10
Paths	8
Size

Total Lines	25
Code Lines	15
Duplication

Lines	10
Ratio	40 %
Importance

Changes
Metric	Value
dl	10
loc	25
rs	4.8196
c	0
b	0
f	0
cc	10
eloc	15
nc	8
nop	0
How to fix Complexity

<?php

namespace POData\Providers\Stream;

use POData\IService;
use POData\Providers\Metadata\ResourceStreamInfo;
use POData\OperationContext\ServiceHost;
use POData\Common\Version;
use POData\Common\ODataException;
use POData\Common\ODataConstants;
use POData\Common\Messages;
use POData\Common\InvalidOperationException;
use POData\Providers\Stream\IStreamProvider;
use POData\Providers\Stream\IStreamProvider2;

/**
 * Class StreamProviderWrapper Wrapper over IDSSP and IDSSP2 implementations.
 * @package POData\Providers\Stream
 */
class StreamProviderWrapper
{
    /**
     * Holds reference to the data service instance.
     * 
     * @var IService
     */
    private $_service;

    /**
     * Holds reference to the implementation of IStreamProvider or IStreamProvider2.
     *
     * 
     * @var IStreamProvider|IStreamProvider2
     */
    private $_streamProvider;

    /**
     * Used to check whether interface implementation modified response content type header or not.
     *
     *
     * @var string|null
     */
    private $_responseContentType;

    /**
     * Used to check whether interface implementation modified ETag header or not.
     *
     * @var string|null
     */
    private $_responseETag;


    /**
     * To set reference to the data service instance.
     * 
     * @param IService $service The data service instance.
     * 
     * @return void
     */
    public function setService(IService $service)
    {
        $this->_service = $service;
    }

    /**
     * To get stream associated with the given media resource.
     * 
     * @param object             $entity             The media resource.
     * @param ResourceStreamInfo $resourceStreamInfo This will be null if media
     *                                               resource is MLE, if media 
     *                                               resource is named
     *                                               stream then will be the 
     *                                               ResourceStreamInfo instance 
     *                                               holding the details of 
     *                                               named stream.
     * 
     * @return string|null
     */
    public function getReadStream($entity, $resourceStreamInfo)
    {
        $requestETag = null;
        $checkETagForEquality = null;
        $this->_getETagFromHeaders($requestETag, $checkETagForEquality);
        $stream = null;
        try {
            $this->_saveContentTypeAndETag();
            if (is_null($resourceStreamInfo)) {
                $this->_loadAndValidateStreamProvider();
                $stream = $this->_streamProvider->getReadStream(
                    $entity,
                    $requestETag,
                    $checkETagForEquality,
                    $this->_service->getOperationContext()
                );
            } else {
                $this->_loadAndValidateStreamProvider2();
                $stream = $this->_streamProvider->getReadStream2(
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                    $entity,
                    $resourceStreamInfo,
                    $requestETag,
                    $checkETagForEquality,
                    $this->_service->getOperationContext()
                );
            }

            $this->_verifyContentTypeOrETagModified('IDSSP::getReadStream');
        } catch(ODataException $ex) {
            //Check for status code 304 (stream Not Modified)
            if ($ex->getStatusCode() == 304) {
                $eTag = $this->getStreamETag($entity, $resourceStreamInfo);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                if (!is_null($eTag)) {
                    $this->_service->getHost()->setResponseETag($eTag);
                }
            }
            throw $ex;
        }

        if ($resourceStreamInfo == null) {
            // For default streams, we always expect getReadStream()
            // to return a non-null stream.
            if (is_null($stream)) {
                throw new InvalidOperationException(
                    Messages::streamProviderWrapperInvalidStreamFromGetReadStream()
                );
            }
        } else {
            // For named streams, getReadStream() can return null to indicate
            // that the stream has not been created.
            if (is_null($stream)) {
                // 204 == no content                
                $this->_service->getHost()->setResponseStatusCode(204);
            }
        }

        return $stream;
    }

    /**
     * Gets the IANA content type (aka media type) of the stream associated with 
     * the specified media resource.
     * 
     * @param object             $entity             The entity instance 
     *                                               (media resource) associated with
     *                                               the stream for which the content
     *                                               type is to be obtained.
     * @param ResourceStreamInfo $resourceStreamInfo This will be null if 
     *                                               media resource is MLE, 
     *                                               if media resource is named
     *                                               stream then will be the 
     *                                               ResourceStreamInfo instance 
     *                                               holding the details of 
     *                                               named stream.
     * 
     * @return string|null
     */
    public function getStreamContentType($entity, $resourceStreamInfo)

    {
        $contentType = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $this->_saveContentTypeAndETag();
        if (is_null($resourceStreamInfo)) {
            $this->_loadAndValidateStreamProvider();
            $contentType = $this->_streamProvider->getStreamContentType(
                $entity,
                $this->_service->getOperationContext()
            );
            if (is_null($contentType)) {
                throw new InvalidOperationException(
                    Messages::streamProviderWrapperGetStreamContentTypeReturnsEmptyOrNull()
                );
            }
        } else {
            $this->_loadAndValidateStreamProvider2();
            $contentType = $this->_streamProvider->getStreamContentType2(
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                $entity,
                $resourceStreamInfo,
                $this->_service->getOperationContext()
            );
        }

        $this->_verifyContentTypeOrETagModified('IDSSP::getStreamContentType');
        return $contentType;
    }

    /**
     * Get the ETag of the stream associated with the entity specified.
     * 
     * @param object             $entity             The entity instance 
     *                                               (media resource) associated
     *                                               with the stream for which 
     *                                               the etag is to be obtained.
     * @param ResourceStreamInfo $resourceStreamInfo This will be null if 
     *                                               media resource is MLE, 
     *                                               if media resource is named
     *                                               stream then will be the 
     *                                               ResourceStreamInfo
     *                                               instance holding the 
     *                                               details of named stream.
     * 
     * @throws InvalidOperationException
     * @return String Etag
     */
    public function getStreamETag($entity, $resourceStreamInfo)

    {
        $eTag = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $this->_saveContentTypeAndETag();
        if (is_null($resourceStreamInfo)) {
            $this->_loadAndValidateStreamProvider();
            $eTag = $this->_streamProvider->getStreamETag(
                $entity,
                $this->_service->getOperationContext()
            );
        } else {
            $this->_loadAndValidateStreamProvider2();
            $eTag = $this->_streamProvider->getStreamETag2(
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                $entity,
                $resourceStreamInfo,
                $this->_service->getOperationContext()
            );
        }

        $this->_verifyContentTypeOrETagModified('IDSSP::getStreamETag');
        if (!self::isETagValueValid($eTag, true)) {
            throw new InvalidOperationException(
                Messages::streamProviderWrapperGetStreamETagReturnedInvalidETagFormat()
            );
        }

        return $eTag;
    }

    /**
     * Gets the URI clients should use when making retrieve (ie. GET) requests 
     * to the stream.
     * 
     * @param object             $entity             The entity instance 
     *                                               associated with the
     *                                               stream for which a 
     *                                               read stream URI is to
     *                                               be obtained.
     * @param ResourceStreamInfo $resourceStreamInfo This will be null 
     *                                               if media resource
     *                                               is MLE, if media 
     *                                               resource is named
     *                                               stream then will be 
     *                                               the ResourceStreamInfo
     *                                               instance holding the 
     *                                               details of named stream.
     * @param string             $mediaLinkEntryUri  MLE uri.
     * 
     * @return string
     * 
     * @throws InvalidOperationException
     */
    public function getReadStreamUri($entity, $resourceStreamInfo, 
        $mediaLinkEntryUri
    ) {
        $readStreamUri = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $this->_saveContentTypeAndETag();
        if (is_null($resourceStreamInfo)) {
            $this->_loadAndValidateStreamProvider();
            $readStreamUri = $this->_streamProvider->getReadStreamUri(
                $entity,
                $this->_service->getOperationContext()
            );
        } else {
            $this->_loadAndValidateStreamProvider2();
            $readStreamUri = $this->_streamProvider->getReadStreamUri2(
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                $entity,
                $resourceStreamInfo,
                $this->_service->getOperationContext()
            );
        }

        $this->_verifyContentTypeOrETagModified('IDSSP::getReadStreamUri');
        if (!is_null($readStreamUri)) {
            try {
                new \POData\Common\Url($readStreamUri);
            } catch (\POData\Common\UrlFormatException $ex) {
                throw new InvalidOperationException(
                    Messages::streamProviderWrapperGetReadStreamUriMustReturnAbsoluteUriOrNull()
                );
            }            
        } else {
            if (is_null($resourceStreamInfo)) {
                // For MLEs the content src attribute is 
                //required so we cannot return null.
                $readStreamUri
                    = $this->getDefaultStreamEditMediaUri(
                        $mediaLinkEntryUri,
                        null
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    );
            }
        }

        // Note if readStreamUri is null, the self link for the
        // named stream will be omitted.
        return $readStreamUri;
    }

    /**
     * Checks the given value is a valid eTag.
     * 
     * @param string  $etag            eTag to validate.
     * @param boolean $allowStrongEtag True if strong eTag is allowed 
     *                                 False otherwise.
     * 
     * @return boolean
     */
    public static function isETagValueValid($etag, $allowStrongEtag)
    {
        if (is_null($etag) || $etag === '*') {
            return true;
        }

        // HTTP RFC 2616, section 3.11:
        //   entity-tag = [ weak ] opaque-tag
        //   weak       = "W/"
        //   opaque-tag = quoted-string
        $etagValueStartIndex = 1;
        $eTagLength = strlen($etag);

        if (strpos($etag, "W/\"") === 0 && $etag[$eTagLength - 1] == '"') {
            $etagValueStartIndex = 3;
        } else if (!$allowStrongEtag || $etag[0] != '"' 
            || $etag[$eTagLength - 1] != '"'
        ) {
            return false;
        }

        for ($i = $etagValueStartIndex; $i < $eTagLength - 1; $i++) {
            // Format of etag looks something like: W/"etag property values" 
            // or "strong etag value" according to HTTP RFC 2616, if someone 
            // wants to specify more than 1 etag value, then need to specify 
            // something like this: W/"etag values", W/"etag values", ...
            // To make sure only one etag is specified, we need to ensure 
            // that if " is part of the key value, it needs to be escaped.
            if ($etag[$i] == '"') {
                return false;
            }
        }

        return true;
    }

    /**
     * Get ETag header value from request header.
     *      
     * @param mixed &$eTag                 On return, this parameter will hold
     *                                     value of IfMatch or IfNoneMatch
     *                                     header, if this header is absent then
     *                                     this parameter will hold NULL.
     * @param mixed &$checkETagForEquality On return, this parameter will hold
     *                                     true if IfMatch is present, false if
     *                                     IfNoneMatch header is present, null
     *                                     otherwise.
     * 
     * @return void
     */
    private function _getETagFromHeaders(&$eTag, &$checkETagForEquality)
    {
        $dataServiceHost = $this->_service->getHost();
        //TODO Do check for mutual exclusion of RequestIfMatch and
        //RequestIfNoneMatch in ServiceHost
        $eTag = $dataServiceHost->getRequestIfMatch();
        if (!is_null($eTag)) {
            $checkETagForEquality = true;
            return;
        }

        $eTag = $dataServiceHost->getRequestIfNoneMatch();
        if (!is_null($eTag)) {
            $checkETagForEquality = false;
            return;
        }

        $checkETagForEquality = null;
    }

    /**
     * Validates that an implementation of IStreamProvider exists and
     * load it.
     * 
     * @return void
     * 
     * @throws ODataException
     */
    private function _loadAndValidateStreamProvider()
    {
        if (is_null($this->_streamProvider)) {
            $this->_loadStreamProvider();
            if (is_null($this->_streamProvider)) {
                throw ODataException::createInternalServerError(
                    Messages::streamProviderWrapperMustImplementIStreamProviderToSupportStreaming()
                );
            }
        }
    }

    /**
     * Validates that an implementation of IStreamProvider2 exists and
     * load it.
     * 
     * @return void
     * 
     * @throws ODataException
     */
    private function _loadAndValidateStreamProvider2()
    {
        $maxServiceVersion = $this->_service
            ->getConfiguration()
            ->getMaxDataServiceVersion();
        if ($maxServiceVersion->compare(new Version(3, 0)) < 0) {
            throw ODataException::createInternalServerError(
                Messages::streamProviderWrapperMaxProtocolVersionMustBeV3OrAboveToSupportNamedStreams()
            );
        }

        if (is_null($this->_streamProvider)) {
            $this->_loadStreamProvider();
            if (is_null($this->_streamProvider)) {
                throw ODataException::createInternalServerError(
                    Messages::streamProviderWrapperMustImplementStreamProvider2ToSupportNamedStreams()
                );
            } else if (!$this->_streamProvider instanceof IStreamProvider2) {
                throw ODataException::createInternalServerError(
                    Messages::streamProviderWrapperInvalidStream2Instance()
                );
            }
        }
    }

    /**
     * Ask data service to load stream provider instance.
     * 
     * @return void
     * 
     * @throws ODataException
     */
    private function _loadStreamProvider()
    {
        if (is_null($this->_streamProvider)) {
            $maxServiceVersion = $this->_service
                ->getConfiguration()
                ->getMaxDataServiceVersion();
            if ($maxServiceVersion->compare(new Version(3, 0)) >= 0) {
                $this->_streamProvider = $this->_service->getService('IStreamProvider2');
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
                if (!is_null($this->_streamProvider) && (!is_object($this->_streamProvider) || !$this->_streamProvider instanceof IStreamProvider2)) {

                    throw ODataException::createInternalServerError(
                        Messages::streamProviderWrapperInvalidStream2Instance()
                    ); 
                }
            }

            if (is_null($this->_streamProvider)) {
                $this->_streamProvider = $this->_service->getService('IStreamProvider');
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
                if (!is_null($this->_streamProvider) && (!is_object($this->_streamProvider) || !$this->_streamProvider instanceof IStreamProvider)) {

                    throw ODataException::createInternalServerError(
                        Messages::streamProviderWrapperInvalidStreamInstance()
                    );
                }
            }
        }
    }

    /**
     * Construct the default edit media uri from the given media link entry uri.
     * 
     * @param string             $mediaLinkEntryUri  Uri to the media link entry.
     * @param ResourceStreamInfo $resourceStreamInfo Stream info instance, if its
     *                                               null default stream is assumed.
     * 
     * @return string Uri to the media resource.
     */
    public function getDefaultStreamEditMediaUri($mediaLinkEntryUri, $resourceStreamInfo)
    {
        if (is_null($resourceStreamInfo)) {
            return rtrim($mediaLinkEntryUri, '/') . '/' . ODataConstants::URI_VALUE_SEGMENT;
        } else {
            return rtrim($mediaLinkEntryUri, '/') . '/' . ltrim($resourceStreamInfo->getName(), '/');
        }
    }

    /**
     * Save value of content type and etag headers before invoking implementor
     * methods.
     * 
     * @return void
     */
    private function _saveContentTypeAndETag()
    {
        $this->_responseContentType = $this->_service->getHost()->getResponseContentType();
        $this->_responseETag = $this->_service->getHost()->getResponseETag();

    }

    /**
     * Check whether implementor modified content type or etag header
     * if so throw InvalidOperationException.
     * 
     * @param string $methodName NAme of the method
     * 
     * @return void
     * 
     * @throws InvalidOperationException
     */
    private function _verifyContentTypeOrETagModified($methodName)
    {
        if ($this->_responseContentType !== $this->_service->getHost()->getResponseContentType()
            || $this->_responseETag !== $this->_service->getHost()->getResponseETag()
        ) {
            throw new InvalidOperationException(
                Messages::streamProviderWrapperMustNotSetContentTypeAndEtag($methodName)
            );
        }
    }
}

StreamProviderWrapper::_loadStreamProvider() D
last analyzed 2017-02-19 06:57 UTC

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Qeti / POData

StreamProviderWrapper::_loadStreamProvider() D last analyzed 2017-02-19 06:57 UTC

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

StreamProviderWrapper::_loadStreamProvider() D
last analyzed 2017-02-19 06:57 UTC
