/** * {@inheritDoc} */ public function loadMetadata($class) { // Try get object annotation from class $objectAnnotation = null; $classAnnotations = Reflection::loadClassAnnotations($this->reader, $class, true); foreach ($classAnnotations as $classAnnotation) { if ($classAnnotation instanceof ObjectAnnotation) { if ($objectAnnotation) { throw new \RuntimeException(sprintf('Many @Transformer\\Object annotation in class "%s".', $class)); } $objectAnnotation = $classAnnotation; } } if (!$objectAnnotation) { throw new TransformAnnotationNotFoundException(sprintf('Not found @Object annotations in class "%s".', $class)); } // Try get properties annotations $properties = []; $classProperties = Reflection::getClassProperties($class, true); foreach ($classProperties as $classProperty) { $propertyAnnotations = $this->reader->getPropertyAnnotations($classProperty); foreach ($propertyAnnotations as $propertyAnnotation) { if ($propertyAnnotation instanceof PropertyAnnotation) { $property = new PropertyMetadata($propertyAnnotation->propertyName ?: $classProperty->getName(), $propertyAnnotation->groups, $propertyAnnotation->shouldTransform, $propertyAnnotation->expressionValue); $properties[$classProperty->getName()] = $property; } } } return new ObjectMetadata($objectAnnotation->transformedClass, $properties); }
/** * {@inheritDoc} */ public function loadActions() { $actions = new ActionCollection(); foreach ($this->classes as $id => $class) { $reflection = Reflection::loadClassReflection($class); // Get all methods from class $methods = $reflection->getMethods(\ReflectionMethod::IS_PUBLIC); foreach ($methods as $method) { $methodAnnotations = $this->reader->getMethodAnnotations($method); foreach ($methodAnnotations as $annotation) { if ($annotation instanceof ActionAnnotation) { if ($method->isStatic()) { throw new \RuntimeException('The static method not supported (@todo).'); } if ($annotation->response) { $response = new ObjectResponse($annotation->response->class); } else { $response = null; } $action = new ServiceAction($annotation->name, $id, $method->getName(), $annotation->validationGroups, $annotation->securityGroups, $annotation->requestMappingGroup, $annotation->useStrictValidation, $annotation->checkEnabled, $response); $actions->addAction($action); } } } } return $actions; }
/** * {@inheritDoc} */ public function denormalize($data, ContextInterface $context) { if (!is_array($data)) { throw DenormalizationFailedException::unexpected($data, 'array'); } $collectionClass = $context->getAttribute('collection_class'); $class = $context->getAttribute('class'); if (!$class) { throw new DenormalizationFailedException('Undefined denormalizer class.'); } try { $this->normalizerManager->getNormalizerForClass($class); } catch (UnsupportedClassException $e) { throw new DenormalizationFailedException(sprintf('Not found normalizer for denormalize collection. Collection class "%s". Denormalizer class "%s".', $collectionClass, $class), 0, $e); } if ($collectionClass) { $reflection = Reflection::loadClassReflection($collectionClass); $collection = $reflection->newInstanceWithoutConstructor(); } else { $collection = []; } if (is_object($collection) && !$collection instanceof \ArrayAccess) { throw new DenormalizationFailedException(sprintf('The collection instance for denormalize data should implement "ArrayAccess", but "%s" given.', get_class($collection))); } foreach ($data as $key => $childData) { $denormalized = $this->normalizerManager->denormalize($class, $childData); $collection[$key] = $denormalized; } return $collection; }
/** * {@inheritDoc} */ public function load($object, $group) { $reflection = Reflection::loadClassReflection($object); $objectMappingAnnotation = $this->getObjectMappingAnnotation($reflection, $group); if ($objectMappingAnnotation && $objectMappingAnnotation->allProperties) { // Include all properties $propertiesMappingAnnotation = $this->getAllPropertiesMapping($reflection, $objectMappingAnnotation->group); } else { $propertiesMappingAnnotation = $this->getPropertiesMappingAnnotation($reflection, $group); } if (!$objectMappingAnnotation && !$propertiesMappingAnnotation) { return null; } if (!$objectMappingAnnotation) { $strategy = 'reflection'; } else { $strategy = $objectMappingAnnotation->strategy; } $properties = array(); foreach ($propertiesMappingAnnotation as $propertyName => $propertyAnnotation) { $fieldName = $propertyAnnotation->fieldName ?: $propertyName; if ($propertyAnnotation->collection) { $collection = new CollectionMetadata($propertyAnnotation->collection->class, $propertyAnnotation->collection->saveKeys); } else { $collection = null; } $property = new PropertyMetadata($propertyName, $fieldName, $propertyAnnotation->class, $collection); $properties[] = $property; } $objectMetadata = new ObjectMetadata($strategy, $properties); return $objectMetadata; }
/** * {@inheritDoc} */ public function loadForMethod($class, $method, $group) { $methodReflection = Reflection::loadMethodReflection($class, $method); $methodAnnotations = $this->reader->getMethodAnnotations($methodReflection); $securityMethodAnnotation = null; $rules = array(); foreach ($methodAnnotations as $methodAnnotation) { if ($methodAnnotation instanceof MethodSecurityAnnotation && $group == $methodAnnotation->group) { if ($securityMethodAnnotation) { throw new \RuntimeException(sprintf('The @MethodSecurity annotation already defined in method "%s::%s".', $class, $method)); } $securityMethodAnnotation = $methodAnnotation; } if ($rule = $this->transformAnnotationToRule($methodAnnotation, $group, $class)) { $rules[] = $rule; } } if (!$securityMethodAnnotation && !count($rules)) { return null; } if ($securityMethodAnnotation) { $strategy = $securityMethodAnnotation->strategy; } else { $strategy = Security::STRATEGY_AFFIRMATIVE; } $securityMethod = new MethodSecurity($class, $method, $strategy, $rules, $group); return $securityMethod; }
/** * {@inheritDoc} */ public function convertParameter(\ReflectionParameter $parameter, \ReflectionFunctionAbstract $method, $value, $group, array $attributes = []) { $converter = $this->getConverter($group); if (!$converter->isSupported($parameter, $method)) { throw new ConverterNotSupportedException(sprintf('The parameter converter "%s" not supported in function "%s".', $parameter->getName(), Reflection::getCalledMethod($method))); } $value = $converter->convert($parameter, $method, $value, $attributes); return $value; }
/** * {@inheritDoc} */ public function convert(\ReflectionParameter $parameter, \ReflectionFunctionAbstract $method, $value, array $attributes = []) { foreach ($this->converters as $converter) { if (true === $converter->isSupported($parameter, $method)) { return $converter->convert($parameter, $method, $value, $attributes); } } throw new ConverterNotFoundException(sprintf('Not found parameter converter for argument "%s" in function "%s".', $parameter->getName(), Reflection::getCalledMethod($method))); }
/** * {@inheritDoc} */ public function resolve(ActionInterface $action) { if (!$action instanceof ServiceAction) { throw UnexpectedTypeException::create($action, 'FivePercent\\Bundle\\ApiBundle\\SMD\\Action\\ServiceAction'); } $serviceId = $action->getServiceId(); $method = $action->getMethod(); $service = $this->container->get($serviceId); $reflectionService = Reflection::loadClassReflection($service); $reflectionMethod = $reflectionService->getMethod($method); return new BaseCallable($reflectionMethod, $service); }
/** * {@inheritDoc} */ protected function getPropertiesForClass(ActionInterface $action, CallableInterface $callable, $class) { if (!$this->metadataFactory->supportsClass($class)) { return []; } $metadata = $this->metadataFactory->loadMetadata($class); $reflectionClass = Reflection::loadClassReflection($class); $properties = []; foreach ($metadata->getProperties() as $propertyName => $property) { $properties[] = $reflectionClass->getProperty($propertyName); } return $properties; }
/** * {@inheritDoc} */ public function convertProperties($object, $group) { if (!is_object($object)) { throw UnexpectedTypeException::create($object, 'object'); } $converter = $this->getConverter($group); $classReflection = Reflection::loadClassReflection($object); $properties = $classReflection->getProperties(); foreach ($properties as $property) { if ($converter->isSupported($property)) { $this->convertPropertyReflection($object, $property, $group); } } }
/** * {@inheritDoc} */ public function map(PropertyMetadata $property, $object, $value) { if (!is_object($object)) { throw UnexpectedTypeException::create($object, 'object'); } if (!$property->reflection) { $objectReflection = Reflection::loadObjectReflection($object); $propertyName = $property->getPropertyName(); $propertyReflection = $objectReflection->getProperty($propertyName); if (!$propertyReflection->isPublic()) { $propertyReflection->setAccessible(true); } $property->reflection = $propertyReflection; } $property->reflection->setValue($object, $value); }
/** * {@inheritDoc} */ public function loadMetadata($class) { // Try get @Object annotation $objectAnnotation = null; $classAnnotations = Reflection::loadClassAnnotations($this->reader, $class); foreach ($classAnnotations as $classAnnotation) { if ($classAnnotation instanceof ObjectAnnotation) { if ($objectAnnotation) { throw new \RuntimeException(sprintf('Many @Normalize\\Object annotations in class "%s".', $class)); } $objectAnnotation = $classAnnotation; } } // Try get @Property annotation from properties $properties = []; $classProperties = Reflection::getClassProperties($class, true); if ($objectAnnotation && $objectAnnotation->allProperties) { foreach ($classProperties as $classProperty) { /** @var PropertyAnnotation $propertyAnnotation */ $propertyAnnotation = $this->reader->getPropertyAnnotation($classProperty, 'FivePercent\\Component\\ModelNormalizer\\Annotation\\Property'); if ($propertyAnnotation) { $properties[$classProperty->getName()] = new PropertyMetadata($propertyAnnotation->fieldName ?: $classProperty->getName(), $propertyAnnotation->groups, $propertyAnnotation->shouldNormalize, $propertyAnnotation->expressionValue, $propertyAnnotation->denormalizerClass); } else { $properties[$classProperty->getName()] = new PropertyMetadata($classProperty->getName(), [], false, null); } } } else { foreach ($classProperties as $classProperty) { $propertyAnnotations = $this->reader->getPropertyAnnotations($classProperty); foreach ($propertyAnnotations as $propertyAnnotation) { if ($propertyAnnotation instanceof PropertyAnnotation) { $properties[$classProperty->getName()] = new PropertyMetadata($propertyAnnotation->fieldName ?: $classProperty->getName(), $propertyAnnotation->groups, $propertyAnnotation->shouldNormalize, $propertyAnnotation->expressionValue, $propertyAnnotation->denormalizerClass); } } } } if (!count($properties) && !$objectAnnotation) { throw new NormalizeAnnotationNotFoundException(sprintf('Not found normalize annotations in class "%s".', $class)); } return new ObjectMetadata($properties); }
/** * {@inheritDoc} */ protected function execute(InputInterface $input, OutputInterface $output) { $handlerRegistry = $this->getContainer()->get('api.handler_registry'); $callableResolver = $this->getContainer()->get('api.callable_resolver'); $projectDirectory = realpath($this->getContainer()->getParameter('kernel.root_dir') . '/..'); $handlerKeys = $handlerRegistry->getHandlerKeys(); if ($input->getArgument('handler')) { $handlerKeys = array_diff($handlerKeys, array_diff($handlerKeys, $input->getArgument('handler'))); } if (!count($handlerKeys)) { $output->writeln('Not found handlers.'); return 0; } foreach ($handlerKeys as $handlerKey) { $handler = $handlerRegistry->getHandler($handlerKey); $actions = $handler->getActions(); /** @var \Symfony\Component\Console\Helper\Table $table */ $table = $this->getHelper('table'); $table->setHeaders(['Name', 'Callable', 'File / Line']); $rows = []; foreach ($actions as $action) { try { $callable = $callableResolver->resolve($action); } catch (\Exception $e) { $rows[] = [$action->getName(), '<error>Not supported</error>', '']; continue; } $reflection = $callable->getReflection(); $file = str_replace($projectDirectory, '', $reflection->getFileName()); $callableName = Reflection::getCalledMethod($callable->getReflection(), false); $fileAndLine = sprintf('%s on lines %d:%d', ltrim($file, '/'), $reflection->getStartLine(), $reflection->getEndLine()); $rows[] = [$action->getName(), $callableName, $fileAndLine]; } $output->writeln(sprintf('Action list for handler <info>%s</info>:', $handlerKey)); $table->setRows($rows); $table->render($output); $output->writeln([null, null]); } return 0; }
/** * {@inheritDoc} */ public function loadMetadata($class) { $notifications = []; $classAnnotations = Reflection::loadClassAnnotations($this->reader, $class); $withoutOnEventParameter = false; foreach ($classAnnotations as $classAnnotation) { if ($classAnnotation instanceof NotificationAnnotation) { if (!$classAnnotation->onEvent) { $withoutOnEventParameter = true; } $notification = new NotificationMetadata($classAnnotation->name, $classAnnotation->strategy, $classAnnotation->onEvent); $notifications[] = $notification; } } if (count($notifications) > 1 && $withoutOnEventParameter) { throw new \RuntimeException(sprintf('The parameter "onEvent" is required, if you use many @Notification annotation in class "%s".', $class)); } if (count($notifications) == 0) { throw new NotificationAnnotationNotFoundException(sprintf('Not found @Notification annotation in class "%s".', $class)); } return new ClassMetadata($notifications); }
/** * {@inheritDoc} */ public function loadMetadata($class) { $properties = Reflection::getClassProperties($class, true); $metadataProperties = []; foreach ($properties as $property) { $docBlock = new DocBlock($property); $docVarTags = $docBlock->getTagsByName('var'); if (count($docVarTags)) { /** @var \phpDocumentor\Reflection\DocBlock\Tag\VarTag $docVarTag */ $docVarTag = array_pop($docVarTags); $types = $docVarTag->getTypes(); $types = array_map(function ($type) { return ltrim($type, '\\'); }, $types); if (count($types)) { $propertyMetadata = new PropertyMetadata($types); $metadataProperties[$property->getName()] = $propertyMetadata; } } } $classMetadata = new ClassMetadata($metadataProperties); return $classMetadata; }
/** * {@inheritDoc} */ public function transform($object, ContextInterface $context) { $metadata = $this->metadataFactory->loadMetadata(get_class($object)); // Get properties for transformation if (!$context->getGroups()) { $transformProperties = $metadata->getProperties(); } else { $transformProperties = $metadata->getPropertiesForGroups($context->getGroups()); } // Try create transformed $transformedClass = $metadata->getTransformedClass(); $transformedReflection = Reflection::loadClassReflection($transformedClass); $transformed = $transformedReflection->newInstanceWithoutConstructor(); $objectReflection = Reflection::loadClassReflection($object); foreach ($transformProperties as $transformPropertyName => $propertyMetadata) { try { $objectPropertyReflection = $objectReflection->getProperty($transformPropertyName); } catch (\ReflectionException $e) { throw new \RuntimeException(sprintf('Error transform property: Not found property "%s" in class "%s".', $transformPropertyName, $objectReflection->getName()), 0, $e); } try { $transformedPropertyReflection = $transformedReflection->getProperty($propertyMetadata->getPropertyName()); } catch (\ReflectionException $e) { throw new \RuntimeException(sprintf('Error transform property: Not found property "%s" in class "%s".', $propertyMetadata->getPropertyName(), $transformedReflection->getName())); } if (!$transformedPropertyReflection->isPublic()) { $transformedPropertyReflection->setAccessible(true); } if (!$objectPropertyReflection->isPublic()) { $objectPropertyReflection->setAccessible(true); } $objectPropertyValue = $objectPropertyReflection->getValue($object); $transformedValue = $this->transformValue($object, $objectPropertyValue, $propertyMetadata, $transformedPropertyReflection); $transformedPropertyReflection->setValue($transformed, $transformedValue); } return $transformed; }
/** * Get converter annotation * * @param \ReflectionParameter $parameter * @param \ReflectionMethod $method * * @return ORM * * @throws ORMAnnotationNotFoundException */ private function getConverterAnnotation(\ReflectionParameter $parameter, \ReflectionMethod $method) { $annotations = $this->reader->getMethodAnnotations($method); foreach ($annotations as $annotation) { if ($annotation instanceof ORM) { // Check parameter name if ($annotation->name === $parameter->name) { return $annotation; } // Check classes if ($class = $parameter->getClass()) { if (is_a($class->getName(), $annotation->entityClass, true)) { return $annotation; } } if (!$annotation->name && !$annotation->entityClass) { throw new \RuntimeException(sprintf('Invalid @ORM annotation. The name or entity class must be specified in method "%s".', Reflection::getCalledMethod($method))); } } } throw new ORMAnnotationNotFoundException(sprintf('Not found ORM annotation for parameter "%s" in method "%s".', $parameter->getName(), Reflection::getCalledMethod($method))); }
/** * Create a new object by class * * @param string $class * * @return object */ protected function createObjectFromClass($class) { $reflection = Reflection::loadClassReflection($class); if (!$reflection->isUserDefined()) { // PHP System class return $reflection->newInstance(); } $constructor = $reflection->getConstructor(); if (!$constructor) { // Constructor not found return $reflection->newInstanceWithoutConstructor(); } $constructorParameters = $constructor->getParameters(); // Is constructor has required parameter $constructorHasRequiredParameter = false; foreach ($constructorParameters as $constructorParameter) { if (!$constructorParameter->isOptional()) { $constructorHasRequiredParameter = true; break; } } if ($constructorHasRequiredParameter) { return $reflection->newInstanceWithoutConstructor(); } else { return $reflection->newInstance(); } }
/** * {@inheritDoc} */ public function handle($method, array $parameters) { try { // Get action and callable $action = $this->actionManager->getAction($method); $callable = $this->callableResolver->resolve($action); // Resolve parameters $parameters = $this->parameterResolver->resolve($action, $callable, $parameters); // Dispatch "pre dispatch" event $event = new ActionDispatchEvent($action, $callable, $parameters); $this->eventDispatcher->dispatch(ApiEvents::ACTION_PRE_DISPATCH, $event); // Call to API method $response = $callable->apply($parameters); if (null === $response) { throw new \RuntimeException(sprintf('The callable "%s" should be return Response or any values. Can not be empty.', Reflection::getCalledMethod($callable->getReflection()))); } if (!$response instanceof ResponseInterface) { // Try transform in listeners. $event = new ActionViewEvent($action, $callable, $parameters, $response); $this->eventDispatcher->dispatch(ApiEvents::ACTION_VIEW, $event); $response = $event->getResponse(); if (!$response) { throw new \RuntimeException(sprintf('Not found response after dispatch view event in API method "%s". ' . 'You must return response or transform response in view event. ' . 'Maybe not found transformer for object?', Reflection::getCalledMethod($callable->getReflection()))); } if (!$response instanceof ResponseInterface) { throw new \RuntimeException(sprintf('The response after dispatch view event must be a ResponseInterface instance, but "%s" given ' . 'for method "%s".', is_object($response) ? get_class($response) : gettype($response))); } } $event = new ActionDispatchEvent($action, $callable, $parameters, $response); $this->eventDispatcher->dispatch(ApiEvents::ACTION_POST_DISPATCH, $event); return $response; } catch (\Exception $e) { $event = new ActionExceptionEvent(isset($action) ? $action : null, $e); $this->eventDispatcher->dispatch(ApiEvents::ACTION_EXCEPTION, $event); if ($event->hasResponse()) { return $event->getResponse(); } throw $e; } }
/** * Test with child collection */ public function testWithChildCollection() { $object = new WithCollectionObject(); $this->objectMapper->map($object, ['name' => 'Foo', 'simpleObject' => ['name' => 'Simple object'], 'simpleObjects' => [['name' => '#1'], ['name' => '#2']]]); $this->assertEquals('Foo', Reflection::getPropertyValue($object, 'name')); $simpleObject = Reflection::getPropertyValue($object, 'simpleObject'); $this->assertInstanceOf('FivePercent\\Component\\ObjectMapper\\Tests\\Mapping\\SimpleObject', $simpleObject); $this->assertEquals('Simple object', Reflection::getPropertyValue($simpleObject, 'name')); $simpleObjects = Reflection::getPropertyValue($object, 'simpleObjects'); $this->assertInstanceOf('ArrayAccess', $simpleObjects); $this->assertFalse(empty($simpleObjects[0])); $this->assertFalse(empty($simpleObjects[1])); $object1 = $simpleObjects[0]; $this->assertInstanceOf('FivePercent\\Component\\ObjectMapper\\Tests\\Mapping\\SimpleObject', $object1); $this->assertEquals('#1', Reflection::getPropertyValue($object1, 'name')); $object2 = $simpleObjects[1]; $this->assertInstanceOf('FivePercent\\Component\\ObjectMapper\\Tests\\Mapping\\SimpleObject', $object2); $this->assertEquals('#2', Reflection::getPropertyValue($object2, 'name')); }
/** * Resolve request parameter * * @param ActionInterface $action * @param CallableInterface $callable * @param array $inputArguments * @param \ReflectionParameter $parameter * * @return object * * @throws \Exception */ private function resolveRequest(ActionInterface $action, CallableInterface $callable, array $inputArguments, \ReflectionParameter $parameter) { $class = $parameter->getClass(); if ($class->isInterface()) { throw new \RuntimeException(sprintf('Could not create instance via interface for parameter "%s" in method "%s". ' . 'You must set the class for type hinting.', $parameter->getName(), Reflection::getCalledMethod($callable->getReflection()))); } if ($class->isAbstract()) { throw new \RuntimeException(sprintf('Could not create instance via abstract class for parameter "%s" in method "%s". ' . 'You must set the real class for type hinting.', $parameter->getName(), Reflection::getCalledMethod($callable->getReflection()))); } /** @var RequestInterface $request */ $request = $class->newInstance(); // Map arguments $this->objectMapper->map($request, $inputArguments, $action->getRequestMappingGroup()); // First step validation: Strict mode if ($this->validator && $action->isStrictValidation()) { $this->strictRequestValidate($request); } // Second step validation: Base validation if ($this->validator && $action->getValidationGroups()) { $violationList = $this->validator->validate($request, null, $action->getValidationGroups()); if (count($violationList)) { throw ViolationListException::create($violationList); } } // Convert request properties if ($this->propertyConverter) { try { $this->propertyConverter->convertProperties($request, PropertyConverterManagerInterface::GROUP_DEFAULT); } catch (InvalidArgumentException $e) { $constraintViolation = new ConstraintViolation($e->getMessage(), null, [], null, $e->getName(), $e->getInvalidValue()); $constraintViolationList = new ConstraintViolationList([$constraintViolation]); throw ViolationListException::create($constraintViolationList); } catch (ConverterNotFoundException $e) { if ($this->logger) { $this->logger->warning(sprintf('Could not convert properties with message: %s.', rtrim($e->getMessage(), '.'))); } // Nothing action } } return $request; }
/** * Validate property value by types * * @param object $object * @param string $propertyName * @param array $types * * @return null|\Symfony\Component\Validator\ConstraintViolationInterface[] */ private function validatePropertyValueByTypes($object, $propertyName, array $types) { $classReflection = Reflection::loadClassReflection($object); $property = $classReflection->getProperty($propertyName); if (!$property->isPublic()) { $property->setAccessible(true); } $value = $property->getValue($object); if (!$value) { return null; } $firstViolationList = null; foreach ($types as $type) { try { $varTagConstraint = $this->constraintFactoryRegistry->getConstraintFactory($type)->getVarTagConstraint(); } catch (ConstraintFactoryNotFoundException $e) { continue; } $constraints = $varTagConstraint->getConstraints(); $groupSequence = $varTagConstraint->getGroupSequence(); if (count($constraints)) { $violationList = $this->validator->validate($value, $constraints, $groupSequence); if (count($violationList)) { if (!$firstViolationList) { $firstViolationList = $violationList; } } else { return null; } } } return $firstViolationList; }
/** * {@inheritDoc} */ public function denormalize($data, ContextInterface $context) { $class = $context->getAttribute('_class'); if (!$class) { throw new DenormalizationFailedException('Undefined class for denormalization'); } $metadata = $this->metadataFactory->loadMetadata($class); if ($context->getGroups()) { $denormalizeProperties = $metadata->getPropertiesForGroups($context->getGroups()); } else { $denormalizeProperties = $metadata->getProperties(); } $classReflection = Reflection::loadClassReflection($class); if ($object = $context->getAttribute('_object')) { if (!is_object($object)) { throw UnexpectedTypeException::create($object, 'object'); } if (get_class($object) != $classReflection && !is_a($object, $class)) { throw UnexpectedTypeException::create($object, $class); } } else { $object = $classReflection->newInstanceWithoutConstructor(); } foreach ($denormalizeProperties as $denormalizePropertyName => $propertyMetadata) { $fieldName = $propertyMetadata->getFieldName(); if (!isset($data[$fieldName])) { continue; } $objectPropertyReflection = $classReflection->getProperty($denormalizePropertyName); if (!$objectPropertyReflection->isPublic()) { $objectPropertyReflection->setAccessible(true); } $denormalizedValue = $this->denormalizeValue($data[$fieldName], $propertyMetadata, $objectPropertyReflection); $objectPropertyReflection->setValue($object, $denormalizedValue); } return $object; }
/** * Get properties for class * * @param ActionInterface $action * @param CallableInterface $callable * @param string $class * * @return \ReflectionProperty[] */ protected function getPropertiesForClass(ActionInterface $action, CallableInterface $callable, $class) { return Reflection::getClassProperties($class); }
/** * On pre dispatch event * * @param ActionDispatchEvent $event */ public function onPreDispatch(ActionDispatchEvent $event) { $message = sprintf('Match callable "%s" for action "%s".', Reflection::getCalledMethod($event->getCallable()->getReflection()), $event->getAction()->getName()); $this->logger->debug($message); }