/**
* Creates new instance of Navigation
*
* @param ResourceType $resourceType The resource type for this navigation.
*/
public function __construct($resourceType)
{
if ($resourceType->getResourceTypeKind() != ResourceTypeKind::COMPLEX && $resourceType->getResourceTypeKind() != ResourceTypeKind::ENTITY) {
throw new InvalidArgumentException(Messages::navigationInvalidResourceType());
}
$this->_resourceType = $resourceType;
}
/**
* Creates new intstance of ResourceSet
*
* @param string $name Name of the resource set (entity set)
* @param ResourceType $resourceType ResourceType describing the resource
* this entity set holds
*
* @throws InvalidArgumentException
*/
public function __construct($name, ResourceType $resourceType)
{
if ($resourceType->getResourceTypeKind() != ResourceTypeKind::ENTITY) {
throw new \InvalidArgumentException(Messages::resourceSetContainerMustBeAssociatedWithEntityType());
}
$this->_name = $name;
$this->_resourceType = $resourceType;
}
/**
* Write value of a bag instance.
*
* @param array/NULL &$BagValue Bag value to write.
* @param string $propertyName Property name of the bag.
* @param ResourceType &$resourceType Type describing the
* bag value.
* @param string $relativeUri Relative Url to the bag.
* @param ODataPropertyContent &$odataPropertyContent On return, this object
* will hold bag value which
* can be used by writers.
*
* @return void
*/
private function _writeBagValue(&$BagValue, $propertyName, ResourceType &$resourceType, $relativeUri, ODataPropertyContent &$odataPropertyContent)
{
$bagItemResourceTypeKind = $resourceType->getResourceTypeKind();
$this->assert($bagItemResourceTypeKind == ResourceTypeKind::PRIMITIVE || $bagItemResourceTypeKind == ResourceTypeKind::COMPLEX, '$bagItemResourceTypeKind == ResourceTypeKind::PRIMITIVE
|| $bagItemResourceTypeKind == ResourceTypeKind::COMPLEX');
$odataProperty = new ODataProperty();
$odataProperty->name = $propertyName;
$odataProperty->typeName = 'Collection(' . $resourceType->getFullName() . ')';
if (is_null($BagValue) || is_array($BagValue) && empty($BagValue)) {
$odataProperty->value = null;
} else {
$odataBagContent = new ODataBagContent();
foreach ($BagValue as $itemValue) {
if (!is_null($itemValue)) {
if ($bagItemResourceTypeKind == ResourceTypeKind::PRIMITIVE) {
$primitiveValueAsString = null;
$this->_primitiveToString($resourceType, $itemValue, $primitiveValueAsString);
$odataBagContent->propertyContents[] = $primitiveValueAsString;
} else {
if ($bagItemResourceTypeKind == ResourceTypeKind::COMPLEX) {
$complexContent = new ODataPropertyContent();
$actualType = $this->_complexObjectToContent($itemValue, $propertyName, $resourceType, $relativeUri, $complexContent);
//TODO add type in case of base type
$odataBagContent->propertyContents[] = $complexContent;
}
}
}
}
$odataProperty->value = $odataBagContent;
}
$odataPropertyContent->odataProperty[] = $odataProperty;
}
/**
* Gets the visible resource properties for the given resource type from
* the given resource set wrapper.
*
* @param ResourceSetWrapper &$resourceSetWrapper Resource set wrapper in
* question.
* @param ResourceType &$resourceType Resource type in question.
*
* @return array(string, ResourceProperty) Collection of visible resource
* properties from the given resource set wrapper and resource type.
*/
public function getResourceProperties(ResourceSetWrapper &$resourceSetWrapper, ResourceType &$resourceType)
{
if ($resourceType->getResourceTypeKind() == ResourceTypeKind::ENTITY) {
$cacheKey = $resourceSetWrapper->getName() . '_' . $resourceType->getFullName();
if (array_key_exists($cacheKey, $this->_resourcePropertyCache)) {
return $this->_resourcePropertyCache[$cacheKey];
}
$this->_resourcePropertyCache[$cacheKey] = array();
foreach ($resourceType->getAllProperties() as $resourceProperty) {
//Check whether this is a visible navigation property
if ($resourceProperty->getTypeKind() == ResourceTypeKind::ENTITY && !is_null($this->getResourceSetWrapperForNavigationProperty($resourceSetWrapper, $resourceType, $resourceProperty))) {
$this->_resourcePropertyCache[$cacheKey][$resourceProperty->getName()] = $resourceProperty;
} else {
//primitive, bag or complex property
$this->_resourcePropertyCache[$cacheKey][$resourceProperty->getName()] = $resourceProperty;
}
}
return $this->_resourcePropertyCache[$cacheKey];
} else {
//Complex resource type
return $resourceType->getAllProperties();
}
}
/**
* To add a complex property to entity or complex type
*
* @param ResourceType $resourceType The resource type to which the
* complex property needs to add
* @param string $name name of the complex property
* @param ResourceType $complexResourceType complex resource type
* @param Boolean $isBag complex type is bag or not
*
* @return ResourceProperty
*/
public function addComplexProperty($resourceType, $name, $complexResourceType, $isBag = false)
{
if ($resourceType->getResourceTypeKind() != ResourceTypeKind::ENTITY && $resourceType->getResourceTypeKind() != ResourceTypeKind::COMPLEX) {
throw new InvalidOperationException('complex property can be added to an entity or another complex type');
}
try {
$resourceType->getInstanceType()->getProperty($name);
} catch (ReflectionException $ex) {
throw new InvalidOperationException('Can\'t add a property which does not exist on the instance type.');
}
$kind = ResourcePropertyKind::COMPLEX_TYPE;
if ($isBag) {
$kind = $kind | ResourcePropertyKind::BAG;
}
$resourceProperty = new ResourceProperty($name, null, $kind, $complexResourceType);
$resourceType->addProperty($resourceProperty);
return $resourceProperty;
}
/**
* test ResourceType class
*/
public function testResourceType()
{
try {
$exceptionThrown = false;
try {
ResourceType::getPrimitiveResourceType(TypeCode::VOID);
} catch (\InvalidArgumentException $exception) {
$exceptionThrown = true;
$this->assertStringEndsWith('is not a valid EdmPrimitiveType Enum value', $exception->getMessage());
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidArgumentException for \'EdmPrimitiveType\' has not been raised');
}
$int16ResType = new ResourceType(new Int16(), ResourceTypeKind::PRIMITIVE, 'Int16', 'Edm');
$exceptionThrown = false;
try {
$int32ResType = new ResourceType(new Int32(), ResourceTypeKind::PRIMITIVE, 'Int32', 'Edm', $int16ResType);
} catch (\InvalidArgumentException $exception) {
$this->AssertEquals('Primitive type cannot have base type', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidArgumentException for \'basetype\' has not been raised');
}
$exceptionThrown = false;
try {
$int32ResType = new ResourceType(new Int32(), ResourceTypeKind::PRIMITIVE, 'Int32', 'Edm', null, true);
} catch (\InvalidArgumentException $exception) {
$this->AssertEquals('Primitive type cannot be abstract', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidArgumentException for \'abstract\' has not been raised');
}
$exceptionThrown = false;
try {
$int32ResType = new ResourceType(null, ResourceTypeKind::PRIMITIVE, 'Int32', 'Edm');
} catch (\InvalidArgumentException $exception) {
$this->assertStringEndsWith('should be an \'IType\' implementor instance', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidArgumentException for \'IType\' has not been raised');
}
$exceptionThrown = false;
try {
$customerResType = new ResourceType(null, ResourceTypeKind::ENTITY, 'Customer', 'Northwind');
} catch (\InvalidArgumentException $exception) {
$this->assertStringEndsWith('argument should be an \'ReflectionClass\' instance', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidArgumentException for \'ReflectionClass\' has not been raised');
}
$customerResType = new ResourceType(new ReflectionClass('Customer2'), ResourceTypeKind::ENTITY, 'Customer', 'Northwind');
$this->AssertEquals($customerResType->getName(), 'Customer');
$this->AssertEquals($customerResType->getFullName(), 'Northwind.Customer');
$this->assertTrue($customerResType->getInstanceType() instanceof \ReflectionClass);
$this->AssertEquals($customerResType->getNamespace(), 'Northwind');
$this->AssertEquals($customerResType->getResourceTypeKind(), ResourceTypeKind::ENTITY);
$this->AssertEquals($customerResType->isMediaLinkEntry(), false);
$exceptionThrown = false;
try {
$customerResType->validateType();
} catch (InvalidOperationException $exception) {
$this->assertStringEndsWith('Please make sure the key properties are defined for this entity type', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidOperationException for \'No key defined\' has not been raised');
}
$exceptionThrown = false;
try {
$int32ResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::INT32);
$primitiveResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::STRING);
$testProperty = new ResourceProperty('test', null, ResourcePropertyKind::PRIMITIVE, $primitiveResourceType);
$int32ResourceType->addProperty($testProperty);
} catch (InvalidOperationException $exception) {
$this->assertStringEndsWith('ResourceType instances with a ResourceTypeKind equal to \'Primitive\'', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidOperationException for \'property on primitive\' has not been raised');
}
$stringResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::STRING);
$customerIDPrimProperty = new ResourceProperty('CustomerID', null, ResourcePropertyKind::PRIMITIVE | ResourcePropertyKind::KEY, $stringResourceType);
$customerNamePrimProperty = new ResourceProperty('CustomerName', null, ResourcePropertyKind::PRIMITIVE, $stringResourceType);
$intResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::INT32);
$ratingPrimProperty = new ResourceProperty('Rating', null, ResourcePropertyKind::PRIMITIVE, $intResourceType);
$addressResType = new ResourceType(new ReflectionClass('Address2'), ResourceTypeKind::COMPLEX, 'Address', 'Northwind');
$exceptionThrown = false;
try {
$booleanResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::BOOLEAN);
$isPrimaryPrimProperty = new ResourceProperty('IsPrimary', null, ResourcePropertyKind::PRIMITIVE | ResourcePropertyKind::KEY, $booleanResourceType);
$addressResType->addProperty($isPrimaryPrimProperty);
} catch (InvalidOperationException $exception) {
$this->assertStringEndsWith('ResourceType instances with a ResourceTypeKind equal to \'EntityType\'', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidOperationException for \'Key on non-entity\' has not been raised');
}
$booleanResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::BOOLEAN);
$isPrimaryPrimProperty = new ResourceProperty('IsPrimary', null, ResourcePropertyKind::PRIMITIVE, $booleanResourceType);
$addressResType->addProperty($isPrimaryPrimProperty);
$exceptionThrown = false;
try {
$addressResType->addProperty($isPrimaryPrimProperty);
} catch (InvalidOperationException $exception) {
$this->assertStringStartsWith('Property with same name \'IsPrimary\' already exists in type \'Address\'', $exception->getMessage());
$exceptionThrown = true;
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidArgumentException for \'Property duplication\' has not been raised');
}
$exceptionThrown = false;
try {
$addressResType->setMediaLinkEntry(true);
} catch (InvalidOperationException $exception) {
$exceptionThrown = true;
$this->assertStringStartsWith('Cannot apply the HasStreamAttribute', $exception->getMessage());
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidOperationException for \'MLE on non-entity\' has not been raised');
}
$customerAdrComplexType = new ResourceProperty('Address', null, ResourcePropertyKind::COMPLEX_TYPE, $addressResType);
$customerResType->addProperty($customerIDPrimProperty);
$customerResType->addProperty($customerNamePrimProperty);
$customerResType->addProperty($ratingPrimProperty);
$customerResType->addProperty($customerAdrComplexType);
$customerResType->validateType();
$customerProperties = $customerResType->getPropertiesDeclaredOnThisType();
$this->AssertEquals(count($customerProperties), 4);
$customerAllProperties = $customerResType->getAllProperties();
$this->AssertEquals(count($customerProperties), count($customerAllProperties));
$keys = array('CustomerID', 'CustomerName', 'Rating', 'Address');
$i = 0;
foreach ($customerAllProperties as $key => $customerProperty) {
$this->AssertEquals($key, $keys[$i++]);
}
$entityKeys = array('CustomerID');
$customerKeyProperties = $customerResType->getKeyProperties();
$i = 0;
foreach ($customerKeyProperties as $key => $customerKeyProperty) {
$this->AssertEquals($key, $entityKeys[$i++]);
}
$this->AssertEquals(count($customerResType->getETagProperties()), 0);
$this->AssertEquals($customerResType->tryResolvePropertyTypeByName('PropNotExists'), null);
$property = $customerResType->tryResolvePropertyTypeByName('CustomerName');
$this->AssertNotEquals($property, null);
$this->AssertEquals($property->getName(), 'CustomerName');
$employeeResType = new ResourceType(new ReflectionClass('Employee2'), ResourceTypeKind::ENTITY, 'Employee', 'Northwind');
$stringResourceType = ResourceType::getPrimitiveResourceType(EdmPrimitiveType::STRING);
$employeeResType->addProperty(new ResourceProperty('EmployeeID', null, ResourcePropertyKind::PRIMITIVE | ResourcePropertyKind::KEY, $stringResourceType));
$employeeResType->addProperty(new ResourceProperty('Emails', null, ResourcePropertyKind::PRIMITIVE | ResourcePropertyKind::BAG, $stringResourceType));
$employeeResType->setMediaLinkEntry(true);
$employeeResType->addNamedStream(new ResourceStreamInfo('ThumNail_64X64'));
$exceptionThrown = false;
try {
$employeeResType->addNamedStream(new ResourceStreamInfo('ThumNail_64X64'));
} catch (InvalidOperationException $exception) {
$exceptionThrown = true;
$this->assertStringStartsWith('Named stream with the name \'ThumNail_64X64\' already exists in type \'Employee\'', $exception->getMessage());
}
if (!$exceptionThrown) {
$this->fail('An expected InvalidOperationException for \'named stream duplication\' has not been raised');
}
$this->AssertEquals($employeeResType->hasNamedStream(), true);
$b = array();
$this->AssertEquals($employeeResType->hasBagProperty($b), true);
$namedStreams = $employeeResType->getAllNamedStreams();
$this->AssertEquals(count($namedStreams), 1);
$this->AssertTrue(array_key_exists('ThumNail_64X64', $namedStreams));
$name = $employeeResType->tryResolveNamedStreamByName('ThumNail_64X64')->getName();
$this->AssertEquals($name, 'ThumNail_64X64');
} catch (\Exception $exception) {
$this->fail('An unexpected Exception has been raised' . $exception->getMessage());
}
}
/**
* Get the kind of resource type
*
* @return ResourceTypeKind
*/
public function getTypeKind()
{
return $this->_propertyResourceType->getResourceTypeKind();
}