Exemple #1
0
 /**
  * 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;
 }
Exemple #2
0
 /**
  * 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();
 }