ProvidersWrapper::getContainerName() - Code Metrics - Inspection of "Initial post support" - balint777/POData - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( f1c3b7...bffd1d )

by Bálint
created 2017-07-19 11:51 UTC
ProvidersWrapper::getContainerName() A

↳ Parent: ProvidersWrapper
Complexity

Conditions	2
Paths	2
Size

Total Lines	12
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	12
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	7
nc	2
nop	0
<?php

namespace POData\Providers;

use POData\Providers\Metadata\ResourceTypeKind;
use POData\Providers\Metadata\ResourceSetWrapper;
use POData\Providers\Metadata\ResourceType;
use POData\Providers\Metadata\ResourceProperty;
use POData\Providers\Metadata\ResourceSet;
use POData\Providers\Metadata\ResourceAssociationSet;
use POData\Configuration\ServiceConfiguration;
use POData\UriProcessor\ResourcePathProcessor\SegmentParser\KeyDescriptor;
use POData\Common\ODataException;
use POData\Common\Messages;
use POData\Providers\Metadata\EdmSchemaVersion;
use POData\Providers\Query\IQueryProvider;
use POData\Providers\Metadata\IMetadataProvider;
use POData\Providers\Expression\IExpressionProvider;
use POData\Common\InvalidOperationException;
use POData\UriProcessor\QueryProcessor\ExpressionParser\FilterInfo;
use POData\UriProcessor\QueryProcessor\OrderByParser\InternalOrderByInfo;
use POData\Providers\Query\QueryResult;
use POData\Providers\Query\QueryType;

/**
 * Class ProvidersWrapper
 *
 * A wrapper class over IMetadataProvider and IQueryProvider implementations, All calls to implementation of methods
 * of these interfaces should go through this wrapper class so that wrapper methods of this class can perform validation
 *
 * @package POData\Providers
 */
class ProvidersWrapper
{
	/**
	 * Holds reference to IMetadataProvider implementation
	 *
	 * @var IMetadataProvider
	 */
	private $metaProvider;

	/**
	 * Holds reference to IQueryProvider implementation
	 *
	 * @var IQueryProvider
	 *
	 */
	private $queryProvider;

	/**
	 * Holds reference to IServiceConfiguration implementation
	 *
	 * @var ServiceConfiguration
	 */
	private $config;


	/**
	 * Cache for ResourceProperties of a resource type that belongs to a
	 * resource set. An entry (ResourceProperty collection) in this cache
	 * contains only the visible properties of ResourceType.
	 *
	 * @var array(string, array(string, ResourceProperty))
	 */
	private $propertyCache;

	/**
	 * Cache for ResourceSetWrappers. If ResourceSet is invisible value will
	 * be null.
	 *
	 * @var ResourceSetWrapper[] indexed by resource set name
	 */
	private $setWrapperCache;

	/**
	 * Cache for ResourceTypes
	 *
	 * @var ResourceType[] indexed by resource type name
	 */
	private $typeCache;

	/**
	 * Cache for ResourceAssociationSet. If ResourceAssociationSet is invisible
	 * value will be null.
	 *
	 * @var ResourceAssociationSet[] indexed by name
	 */
	private $associationSetCache;

	/**
	 * Creates a new instance of ProvidersWrapper
	 *
	 * @param IMetadataProvider $metadataProvider Reference to IMetadataProvider implementation
	 * @param IQueryProvider    $queryProvider    Reference to IQueryProvider implementation
	 * @param ServiceConfiguration    $configuration    Reference to IServiceConfiguration implementation
	 */
	public function __construct(IMetadataProvider $metadataProvider, IQueryProvider $queryProvider, ServiceConfiguration $configuration)
	{
		$this->metaProvider = $metadataProvider;
		$this->queryProvider = $queryProvider;
		$this->config = $configuration;
		$this->setWrapperCache = array();
		$this->typeCache = array();
		$this->associationSetCache = array();
		$this->propertyCache = array();
	}

	//Wrappers for IMetadataProvider methods

	/**
	 * To get the Container name for the data source,
	 * Note: Wrapper for IMetadataProvider::getContainerName method
	 * implementation
	 *
	 * @return string that contains the name of the container
	 *
	 * @throws ODataException Exception if implementation returns empty container name
	 *
	 */
	public function getContainerName()
	{
		$containerName = $this->metaProvider->getContainerName();
		if (empty($containerName)) {
			throw new ODataException(
				Messages::providersWrapperContainerNameMustNotBeNullOrEmpty(),
				500
			);
		}

		return $containerName;
	}

	/**
	 * To get Namespace name for the data source,
	 * Note: Wrapper for IMetadataProvider::getContainerNamespace method implementation
	 *
	 * @return string that contains the namespace name.
	 *
	 * @throws ODataException Exception if implementation returns empty container namespace
	 *
	 */
	public function getContainerNamespace()
	{
		$containerNamespace = $this->metaProvider->getContainerNamespace();
		if (empty($containerNamespace)) {
			throw new ODataException(
				Messages::providersWrapperContainerNamespaceMustNotBeNullOrEmpty(),
				500
			);
		}

		return $containerNamespace;
	}

	/**
	 * To get the data service configuration
	 *
	 * @return ServiceConfiguration
	 */
	public function getConfiguration()
	{
		return $this->config;
	}

	/**
	 *  To get all entity set information,
	 *  Note: Wrapper for IMetadataProvider::getResourceSets method implementation,
	 *  This method returns array of ResourceSetWrapper instances but the corresponding IDSMP method returns array of ResourceSet instances
	 *
	 *  @return ResourceSetWrapper[] The ResourceSetWrappers for the visible ResourceSets
	 *  @throws ODataException when two resource sets with the same name are encountered
	 *
	 */
	public function getResourceSets()
	{
		$resourceSets = $this->metaProvider->getResourceSets();
		$resourceSetWrappers = array();
		$resourceSetNames = array();
		foreach ($resourceSets as $resourceSet) {
			$name = $resourceSet->getName();
			if (in_array($name, $resourceSetNames)) {
				throw new ODataException(Messages::providersWrapperEntitySetNameShouldBeUnique($name), 500 );
			}

			$resourceSetNames[] = $name;
			$resourceSetWrapper = $this->_validateResourceSetAndGetWrapper($resourceSet);
			if (!is_null($resourceSetWrapper)) {
				$resourceSetWrappers[] = $resourceSetWrapper;
			}
		}

		return $resourceSetWrappers;
	}

	/**
	 * To get all resource types in the data source,
	 * Note: Wrapper for IMetadataProvider::getTypes method implementation
	 *
	 * @return ResourceType[]
	 */
	public function getTypes()
	{
		$resourceTypes = $this->metaProvider->getTypes();
		$resourceTypeNames = array();
		foreach ($resourceTypes as $resourceType) {
			if (in_array($resourceType->getName(), $resourceTypeNames)) {
				throw new ODataException(
					Messages::providersWrapperEntityTypeNameShouldBeUnique($resourceType->getName()),
					500
				);
			}

			$resourceTypeNames[] = $resourceType->getName();
			$this->_validateResourceType($resourceType);
		}

		return $resourceTypes;
	}

	/**
	 * To get a resource set based on the specified resource set name which is
	 * visible,
	 * Note: Wrapper for IMetadataProvider::resolveResourceSet method
	 * implementation
	 *
	 * @param string $name Name of the resource set
	 *
	 * @return ResourceSetWrapper|null Returns resource set with the given name if found, NULL if resource set is set to invisible or not found
	 *
	 */
	public function resolveResourceSet($name)
	{
		if (array_key_exists($name, $this->setWrapperCache)) {
			return $this->setWrapperCache[$name];
		}

		$resourceSet = $this->metaProvider->resolveResourceSet($name);
		if (is_null($resourceSet)) {
			return null;
		}

		return $this->_validateResourceSetAndGetWrapper($resourceSet);
	}

	/**
	 * To get a resource type based on the resource set name,
	 * Note: Wrapper for IMetadataProvider::resolveResourceType
	 * method implementation
	 *
	 * @param string $name Name of the resource set
	 *
	 * @return ResourceType|null resource type with the given resource set name if found else NULL
	 *
	 *
	 * @throws ODataException If the ResourceType is invalid
	 */
	public function resolveResourceType($name)
	{
		$resourceType = $this->metaProvider->resolveResourceType($name);
		if (is_null($resourceType)) {
			return null;
		}

		return $this->_validateResourceType($resourceType);
	}

	/**
	 * The method must return a collection of all the types derived from
	 * $resourceType The collection returned should NOT include the type
	 * passed in as a parameter
	 * Note: Wrapper for IMetadataProvider::getDerivedTypes
	 * method implementation
	 *
	 * @param ResourceType $resourceType Resource to get derived resource types from
	 *
	 * @return ResourceType[]
	 *
	 * @throws InvalidOperationException when the meat provider doesn't return an array
	 */
	public function getDerivedTypes(ResourceType $resourceType)
	{
		$derivedTypes = $this->metaProvider->getDerivedTypes($resourceType);
		if (!is_array($derivedTypes)) {
			throw new InvalidOperationException(Messages::metadataAssociationTypeSetInvalidGetDerivedTypesReturnType($resourceType->getName()));
		}

		foreach ($derivedTypes as $derivedType) {
			$this->_validateResourceType($derivedType);
		}

		return $derivedTypes;
	}

	/**
	 * Returns true if $resourceType represents an Entity Type which has derived
	 * Entity Types, else false.
	 * Note: Wrapper for IMetadataProvider::hasDerivedTypes method
	 * implementation
	 *
	 * @param ResourceType $resourceType Resource to check for derived resource
	 *                                   types.
	 *
	 * @return boolean
	 *
	 * @throws ODataException If the ResourceType is invalid
	 */
	public function hasDerivedTypes(ResourceType $resourceType)
	{
		$this->_validateResourceType($resourceType);
		return $this->metaProvider->hasDerivedTypes($resourceType);
	}

	/**
	 * Gets the ResourceAssociationSet instance for the given source association end,
	 * Note: Wrapper for IMetadataProvider::getResourceAssociationSet
	 * method implementation
	 *
	 * @param ResourceSet $set Resource set of the source association end
	 * @param ResourceType       $type       Resource type of the source association end
	 * @param ResourceProperty   $property   Resource property of the source association end
	 *
	 *
	 * @return ResourceAssociationSet|null Returns ResourceAssociationSet for the source
	 *                                             association end, NULL if no such
	 *                                             association end or resource set in the
	 *                                             other end of the association is invisible
	 */
	public function getResourceAssociationSet(
		ResourceSet $set,
		ResourceType $type,
		ResourceProperty $property
	) {
		$type = $this->_getResourceTypeWherePropertyIsDeclared($type, $property);
		$cacheKey = $set->getName() . '_' . $type->getName() . '_' . $property->getName();

		if (array_key_exists($cacheKey,  $this->associationSetCache)) {
			return $this->associationSetCache[$cacheKey];
		}

		$associationSet = $this->metaProvider->getResourceAssociationSet(
			$set,
			$type,
/** @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);
    }
}
			$property
		);

		if (!is_null($associationSet)) {
			$thisAssociationSetEnd = $associationSet->getResourceAssociationSetEnd(
				$set,
				$type,
/** @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);
    }
}
				$property
			);

			$relatedAssociationSetEnd = $associationSet->getRelatedResourceAssociationSetEnd(
				$set,
				$type,
/** @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);
    }
}
				$property
			);

			//If $thisAssociationSetEnd or $relatedAssociationSetEnd

			//is null means the associationset
			//we got from the IDSMP::getResourceAssociationSet is invalid.
			//AssociationSet::getResourceAssociationSetEnd
			//return null, if AssociationSet's End1 or End2's resourceset name

			//is not matching with the name of
			//resource set wrapper (param1) and resource type is not assignable
			//from given resource type (param2)
			if (is_null($thisAssociationSetEnd) || is_null($relatedAssociationSetEnd)) {
				throw new ODataException(
					Messages::providersWrapperIDSMPGetResourceSetReturnsInvalidResourceSet(
						$set->getName(),
						$type->getFullName(),
						$property->getName()
					),
					500
				);
			}

			$relatedResourceSetWrapper = $this->_validateResourceSetAndGetWrapper(
				$relatedAssociationSetEnd->getResourceSet()
			);
			if ($relatedResourceSetWrapper === null) {
				$associationSet = null;
			} else {
				$this->_validateResourceType($thisAssociationSetEnd->getResourceType());
				$this->_validateResourceType($relatedAssociationSetEnd->getResourceType());
			}
		}

		$this->associationSetCache[$cacheKey] = $associationSet;
		return $associationSet;
	}

	/**
	 * Gets the target resource set wrapper for the given navigation property,
	 * source resource set wrapper and the source resource type
	 *
	 * @param ResourceSetWrapper $resourceSetWrapper         Source resource set.
	 * @param ResourceType       $resourceType               Source resource type.
	 * @param ResourceProperty   $navigationResourceProperty Navigation property.
	 *
	 * @return ResourceSetWrapper|null Returns instance of ResourceSetWrapper
	 *     (describes the entity set and associated configuration) for the
	 *     given navigation property. returns NULL if resourceset for the
	 *     navigation property is invisible or if metadata provider returns
	 *     null resource association set
	 */
	public function getResourceSetWrapperForNavigationProperty(
		ResourceSetWrapper $resourceSetWrapper,
		ResourceType $resourceType,
		ResourceProperty $navigationResourceProperty
	) {
		$associationSet = $this->getResourceAssociationSet(
			$resourceSetWrapper,
			$resourceType,
			$navigationResourceProperty
		);

		if (!is_null($associationSet)) {
			$relatedAssociationSetEnd = $associationSet->getRelatedResourceAssociationSetEnd(
				$resourceSetWrapper->getResourceSet(),
				$resourceType,
				$navigationResourceProperty
			);
			return $this->_validateResourceSetAndGetWrapper(
				$relatedAssociationSetEnd->getResourceSet()
			);
		}

		return null;
	}

	/**
	 * Gets the visible resource properties for the given resource type from the given resource set wrapper.
	 *
	 * @param ResourceSetWrapper $setWrapper Resource set wrapper in question.
	 * @param ResourceType       $resourceType       Resource type in question.
	 * @return ResourceProperty[] Collection of visible resource properties from the given resource set wrapper and resource type.
	 */
	public function getResourceProperties(ResourceSetWrapper $setWrapper, ResourceType $resourceType) {
		if ($resourceType->getResourceTypeKind() != ResourceTypeKind::ENTITY) {
			//Complex resource type
			return $resourceType->getAllProperties();
		}
		//TODO: move this to doctrine annotations
		$cacheKey = $setWrapper->getName() . '_' . $resourceType->getFullName();
		if (!array_key_exists($cacheKey,  $this->propertyCache)) {
			//Fill the cache
			$this->propertyCache[$cacheKey] = array();
			foreach ($resourceType->getAllProperties() as $resourceProperty) {
				//Check whether this is a visible navigation property
				//TODO: is this broken?? see #87
				if ($resourceProperty->getTypeKind() == ResourceTypeKind::ENTITY
					&& !is_null($this->getResourceSetWrapperForNavigationProperty($setWrapper, $resourceType, $resourceProperty))
				) {
					$this->propertyCache[$cacheKey][$resourceProperty->getName()] = $resourceProperty;
				} else {
					//primitive, bag or complex property
					$this->propertyCache[$cacheKey][$resourceProperty->getName()] = $resourceProperty;
				}
			}
		}
		return $this->propertyCache[$cacheKey];

	}

	/**
	 * Wrapper function over _validateResourceSetAndGetWrapper function
	 *
	 * @param ResourceSet $resourceSet see the comments of _validateResourceSetAndGetWrapper
	 *
	 * @return ResourceSetWrapper|null see the comments of _validateResourceSetAndGetWrapper
	 */
	public function validateResourceSetAndGetWrapper(ResourceSet $resourceSet)
	{
		return $this->_validateResourceSetAndGetWrapper($resourceSet);
	}

	/**
	 * Gets the Edm Schema version compliance to the metadata
	 *
	 * @return EdmSchemaVersion
	 */
	public function getEdmSchemaVersion()
	{
		//The minimal schema version for custom provider is 1.1
		return EdmSchemaVersion::VERSION_1_DOT_1;
	}

	/**
	 * This function perform the following operations
	 *  (1) If the cache contain an entry [key, value] for the resourceset then
	 *      return the entry-value
	 *  (2) If the cache not contain an entry for the resourceset then validate
	 *      the resourceset
	 *            (a) If valid add entry as [resouceset_name, resourceSetWrapper]
	 *            (b) if not valid add entry as [resouceset_name, null]
	 *  Note: validating a resourceset means checking the resourceset is visible
	 *  or not using configuration
	 *
	 * @param ResourceSet $resourceSet The resourceset to validate and get the
	 *                                 wrapper for
	 *
	 * @return ResourceSetWrapper|null Returns an instance if a resource set with the given name is visible
	 */
	private function _validateResourceSetAndGetWrapper(ResourceSet $resourceSet)
	{
		$cacheKey = $resourceSet->getName();
		if (array_key_exists($cacheKey, $this->setWrapperCache)) {
			return $this->setWrapperCache[$cacheKey];
		}

		$this->_validateResourceType($resourceSet->getResourceType());
		$wrapper = new ResourceSetWrapper($resourceSet, $this->config);
		if ($wrapper->isVisible()) {
			$this->setWrapperCache[$cacheKey] = $wrapper;
		} else {
			$this->setWrapperCache[$cacheKey] = null;
		}

		return $this->setWrapperCache[$cacheKey];
	}

	/**
	 * Validates the given instance of ResourceType
	 *
	 * @param ResourceType $resourceType The ResourceType to validate
	 *
	 * @return ResourceType
	 *
	 * @throws ODataException Exception if $resourceType is invalid
	 */
	private function _validateResourceType(ResourceType $resourceType)
	{
		$cacheKey = $resourceType->getName();
		if (array_key_exists($cacheKey, $this->typeCache)) {
			return $this->typeCache[$cacheKey];
		}

		//TODO: Do validation if any for the ResourceType
		$this->typeCache[$cacheKey] = $resourceType;
		return $resourceType;
	}

	/**
	 * Gets the resource type on which the resource property is declared on,
	 * If property is not declared in the given resource type, then this
	 * function drill down to the inheritance hierarchy of the given resource
	 * type to find out the base class in which the property is declared
	 *
	 * @param ResourceType     $resourceType     The resource type to start looking
	 * @param ResourceProperty $resourceProperty The resource property in question
	 *
	 * @return ResourceType|null Returns reference to the ResourceType on which
	 *                                   the $resourceProperty is declared, NULL if
	 *                                   $resourceProperty is not declared anywhere
	 *                                   in the inheritance hierarchy
	 */
	private function _getResourceTypeWherePropertyIsDeclared(ResourceType $resourceType,
		ResourceProperty $resourceProperty
	) {
		$type = $resourceType;
		while ($type !== null) {
			if ($type->resolvePropertyDeclaredOnThisType($resourceProperty->getName()) !== null) {
				break;
			}

			$type = $type->getBaseType();
		}

		return $type;
	}

	/**
	 * Gets the underlying custom expression provider, the end developer is
	 * responsible for implementing IExpressionProvider if he choose for
	 *
	 * @return IExpressionProvider Instance of IExpressionProvider implementation.
	 *
	 */
	public function getExpressionProvider()
	{
		$expressionProvider = $this->queryProvider->getExpressionProvider();
		if (is_null($expressionProvider)) {
			throw ODataException::createInternalServerError(Messages::providersWrapperExpressionProviderMustNotBeNullOrEmpty());
		}

		if (!$expressionProvider instanceof IExpressionProvider)
		{
			throw ODataException::createInternalServerError( Messages::providersWrapperInvalidExpressionProviderInstance() );
		}

		return $expressionProvider;
	}

	/**
	 * Indicates if the QueryProvider can handle ordered paging, this means respecting order, skip, and top parameters
	 * If the query provider can not handle ordered paging, it must return the entire result set and POData will
	 * perform the ordering and paging
	 *
	 * @return Boolean True if the query provider can handle ordered paging, false if POData should perform the paging
	 */
	public function handlesOrderedPaging()
	{
		return $this->queryProvider->handlesOrderedPaging();
	}


	private function ValidateQueryResult($queryResult, QueryType $queryType, $methodName){
		if (!$queryResult instanceof QueryResult) {
			throw ODataException::createInternalServerError(
				Messages::queryProviderReturnsNonQueryResult($methodName)
			);
		}

		if($queryType == QueryType::COUNT() || $queryType == QueryType::ENTITIES_WITH_COUNT()){
			//and the provider is supposed to handle the ordered paging they must return a count!
			if($this->queryProvider->handlesOrderedPaging() && !is_numeric($queryResult->count)){
				throw ODataException::createInternalServerError(
					Messages::queryProviderResultCountMissing($methodName, $queryType)
				);
			}

			//If POData is supposed to handle the ordered aging they must return results! (possibly empty)
			if(!$this->queryProvider->handlesOrderedPaging() && !is_array($queryResult->results)){
				throw ODataException::createInternalServerError(
					Messages::queryProviderResultsMissing($methodName, $queryType)
				);
			}
		}

		if(($queryType == QueryType::ENTITIES() || $queryType == QueryType::ENTITIES_WITH_COUNT()) && !is_array($queryResult->results)){
			throw ODataException::createInternalServerError(
				Messages::queryProviderResultsMissing($methodName, $queryType)
			);
		}
	}

	/**
	 * Gets collection of entities belongs to an entity set
	 *
	 * @param QueryType $queryType indicates if this is a query for a count, entities, or entities with a count
	 * @param ResourceSet $resourceSet The entity set containing the entities that need to be fetched
	 * @param FilterInfo $filterInfo represents the $filter parameter of the OData query.  NULL if no $filter specified
	 * @param InternalOrderByInfo $orderBy The orderBy information
	 * @param int $top The top count
	 * @param int $skip The skip count
	 *
	 * @return QueryResult
	 */
	public function getResourceSet(QueryType $queryType, ResourceSet $resourceSet, $filterInfo, $orderBy, $top, $skip, $skiptoken = null, $expansion=null)

	{

		$queryResult = $this->queryProvider->getResourceSet(
			$queryType,
			$resourceSet,
			$filterInfo,
			$orderBy,
			$top,
			$skip,
			$skiptoken,

			$expansion
		);

		$this->validateQueryResult($queryResult, $queryType, 'IQueryProvider::getResourceSet');

		return $queryResult;
	}



	/**
	 * Gets an entity instance from an entity set identified by a key
	 *
	 * @param ResourceSet $resourceSet The entity set containing the entity to fetch
	 * @param KeyDescriptor $keyDescriptor The key identifying the entity to fetch
	 *
	 * @return object|null Returns entity instance if found else null
	 */
	public function getResourceFromResourceSet(ResourceSet $resourceSet, KeyDescriptor $keyDescriptor)
	{
		$entityInstance = $this->queryProvider->getResourceFromResourceSet( $resourceSet, $keyDescriptor );
		$this->_validateEntityInstance(
			$entityInstance,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
			$resourceSet,
			$keyDescriptor,
			'IQueryProvider::getResourceFromResourceSet'
		);
		return $entityInstance;
	}

	/**
	 * Puts an entity instance to entity set identified by a key
	 *
	 * @param ResourceSet $resourceSet The entity set containing the entity to update
	 * @param KeyDescriptor $keyDescriptor The key identifying the entity to update
	 *
	 * @return bool|null Returns result of executiong query
	 */
	public function putResource(
		ResourceSet $resourceSet,
		KeyDescriptor $keyDescriptor,
		$data
	) {
		$queryResult = $this->queryProvider->putResource(

			$resourceSet,
			$keyDescriptor,
			$data
		);

		return $queryResult;
	}

	/**
	 * Posts an entity instance to entity set identified by a key
	 *
	 * @param ResourceSet $resourceSet The entity set containing the entity to update
	 * @param KeyDescriptor $keyDescriptor The key identifying the entity to update
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
	 *
	 * @return bool|null Returns result of executiong query
	 */
	public function postResource(
		ResourceSet $resourceSet,
		$data
	) {
		$queryResult = $this->queryProvider->postResource(

			$resourceSet,
			$data
		);

		return $queryResult;
	}

	/**
	 * Get related resource set for a resource
	 *
	 * @param QueryType $queryType indicates if this is a query for a count, entities, or entities with a count
	 * @param ResourceSet $sourceResourceSet The entity set containing the source entity
	 * @param object $sourceEntity The source entity instance.
	 * @param ResourceSet      $targetResourceSet    The resource set of containing the target of the navigation property
	 * @param ResourceProperty $targetProperty       The navigation property to retrieve
	 * @param FilterInfo  $filterInfo represents the $filter parameter of the OData query.  NULL if no $filter specified
	 * @param mixed $orderBy sorted order if we want to get the data in some specific order
	 * @param int $top number of records which  need to be skip
	 * @param String $skip value indicating what records to skip
	 *
	 * @return QueryResult
	 *
	 * @throws ODataException
	 */
	public function getRelatedResourceSet(

		QueryType $queryType,
		ResourceSet $sourceResourceSet,
		$sourceEntity,
		ResourceSet $targetResourceSet,
		ResourceProperty $targetProperty,
		$filterInfo,
		$orderBy,
		$top,
		$skip
	) {

		$queryResult = $this->queryProvider->getRelatedResourceSet(
			$queryType,
			$sourceResourceSet,
			$sourceEntity,
			$targetResourceSet,
			$targetProperty,
			$filterInfo,
			$orderBy,
			$top,
			$skip
		);


		$this->validateQueryResult($queryResult, $queryType, 'IQueryProvider::getRelatedResourceSet');


		return $queryResult;
	}

	/**
	 * Gets a related entity instance from an entity set identified by a key
	 *
	 * @param ResourceSet      $sourceResourceSet The entity set related to the entity to be fetched.
	 * @param object           $sourceEntity      The related entity instance.
	 * @param ResourceSet      $targetResourceSet The entity set from which entity needs to be fetched.
	 * @param ResourceProperty $targetProperty    The metadata of the target property.
	 * @param KeyDescriptor    $keyDescriptor     The key to identify the entity to be fetched.
	 *
	 *
	 * @return object|null Returns entity instance if found else null
	 */
	public function getResourceFromRelatedResourceSet(ResourceSet $sourceResourceSet,
		$sourceEntity, ResourceSet $targetResourceSet, ResourceProperty $targetProperty,
		KeyDescriptor $keyDescriptor
	) {
		$entityInstance = $this->queryProvider->getResourceFromRelatedResourceSet(
			$sourceResourceSet,
			$sourceEntity,
			$targetResourceSet,
			$targetProperty,
			$keyDescriptor
		);

		$this->_validateEntityInstance(
			$entityInstance, $targetResourceSet,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
			$keyDescriptor,
			'IQueryProvider::getResourceFromRelatedResourceSet'
		);
		return $entityInstance;
	}

	/**
	 * Get related resource for a resource
	 *
	 * @param ResourceSet      $sourceResourceSet The source resource set
	 * @param object           $sourceEntity      The source resource
	 * @param ResourceSet      $targetResourceSet The resource set of the navigation
	 *                                            property
	 * @param ResourceProperty $targetProperty    The navigation property to be
	 *                                            retrieved
	 *
	 * @return object|null The related resource if exists else null
	 */
	public function getRelatedResourceReference(ResourceSet $sourceResourceSet,
		$sourceEntity, ResourceSet $targetResourceSet,
		ResourceProperty $targetProperty
	) {
		$entityInstance = $this->queryProvider->getRelatedResourceReference(
			$sourceResourceSet,
			$sourceEntity,
			$targetResourceSet,
			$targetProperty
		);

		// we will not throw error if the resource reference is null
		// e.g. Orders(1234)/Customer => Customer can be null, this is
		// allowed if Customer is last segment. consider the following:
		// Orders(1234)/Customer/Orders => here if Customer is null then
		// the UriProcessor will throw error.
		if (!is_null($entityInstance)) {
			$entityName
				= $targetResourceSet
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.
}
					->getResourceType()
					->getInstanceType()
					->getName();
			if (!is_object($entityInstance)

				|| !($entityInstance instanceof $entityName)
			) {
				throw ODataException::createInternalServerError(
					Messages::providersWrapperIDSQPMethodReturnsUnExpectedType(
						$entityName,
						'IQueryProvider::getRelatedResourceReference'
					)
				);
			}

			foreach ($targetProperty->getResourceType()->getKeyProperties()
			as $keyName => $resourceProperty) {
				try {
					$keyProperty = new \ReflectionProperty(
						$entityInstance,
						$keyName
					);
					$keyProperty->setAccessible(true);
					$keyValue = $keyProperty->getValue($entityInstance);
					if (is_null($keyValue)) {
						throw ODataException::createInternalServerError(
							Messages::providersWrapperIDSQPMethodReturnsInstanceWithNullKeyProperties('IDSQP::getRelatedResourceReference')
						);
					}
				} catch (\ReflectionException $reflectionException) {
					//throw ODataException::createInternalServerError(

					//    Messages::orderByParserFailedToAccessOrInitializeProperty(
					//        $resourceProperty->getName(), $resourceType->getName()

					//    )
					//);
				}
			}
		}

		return $entityInstance;
	}

	/**
	 * Validate the given entity instance.
	 *
	 * @param object        $entityInstance Entity instance to validate
	 * @param ResourceSet   &$resourceSet   Resource set to which the entity
	 *                                      instance belongs to.
	 * @param KeyDescriptor &$keyDescriptor The key descriptor.
	 * @param string        $methodName     Method from which this function
	 *                                      invoked.
	 *
	 * @return void
	 *
	 * @throws ODataException
	 */
	private function _validateEntityInstance($entityInstance,
		ResourceSet &$resourceSet,
		KeyDescriptor &$keyDescriptor,
		$methodName
	) {
		if (is_null($entityInstance)) {
			throw ODataException::createResourceNotFoundError($resourceSet->getName());
		}

		$entityName = $resourceSet->getResourceType()->getInstanceType()->getName();
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.
}
		if (!is_object($entityInstance)

			|| !($entityInstance instanceof $entityName)
		) {
			throw ODataException::createInternalServerError(
				Messages::providersWrapperIDSQPMethodReturnsUnExpectedType(
					$entityName,
					$methodName
				)
			);
		}

		foreach ($keyDescriptor->getValidatedNamedValues()
			as $keyName => $valueDescription) {
			try {
				$keyProperty = new \ReflectionProperty($entityInstance, $keyName);
				$keyProperty->setAccessible(true);
				$keyValue = $keyProperty->getValue($entityInstance);
				if (is_null($keyValue)) {
					throw ODataException::createInternalServerError(
						Messages::providersWrapperIDSQPMethodReturnsInstanceWithNullKeyProperties($methodName)
					);
				}

				$convertedValue
					= $valueDescription[1]->convert($valueDescription[0]);
				if ($keyValue != $convertedValue) {
					throw ODataException::createInternalServerError(
						Messages::providersWrapperIDSQPMethodReturnsInstanceWithNonMatchingKeys($methodName)
					);
				}
			} catch (\ReflectionException $reflectionException) {
				//throw ODataException::createInternalServerError(

				//  Messages::orderByParserFailedToAccessOrInitializeProperty(
				//      $resourceProperty->getName(), $resourceType->getName()

				//  )
				//);
			}
		}
	}

	/**
	 * Assert that the given condition is true.
	 *
	 * @param boolean $condition         Condition to be asserted.
	 * @param string  $conditionAsString String containing message incase
	 *                                   if assertion fails.
	 *
	 * @throws InvalidOperationException Incase if assertion fails.
	 *
	 * @return void
	 */
	protected function assert($condition, $conditionAsString)
	{
		if (!$condition) {
			throw new InvalidOperationException("Unexpected state, expecting $conditionAsString");
		}
	}
}
Push — master ( f1c3b7...bffd1d )

ProvidersWrapper::getContainerName() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

balint777 / POData

Push — master ( f1c3b7...bffd1d )

ProvidersWrapper::getContainerName() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
