/**
* {@inheritDoc}
*/
public function check($object)
{
if (!$object instanceof EnabledIndicateInterface) {
throw UnexpectedTypeException::create($object, 'FivePercent\\Component\\EnabledChecker\\EnabledIndicateInterface');
}
return $object->isEnabled();
}
/**
* {@inheritDoc}
*/
public function resolve(ActionInterface $action)
{
if (!$action instanceof CallableAction) {
throw UnexpectedTypeException::create($action, 'FivePercent\\Component\\Api\\SMD\\Action\\CallableAction');
}
$callable = $action->getCallable();
$object = null;
if ($callable instanceof \Closure) {
$reflection = new \ReflectionFunction($action->getCallable());
} else {
if (is_array($callable)) {
if (is_object($callable[0])) {
$object = $callable[0];
$reflection = new \ReflectionMethod(get_class($callable[0]), $callable[1]);
} else {
$reflection = new \ReflectionMethod($callable[0], $callable[1]);
}
} else {
if (function_exists($callable)) {
$reflection = new \ReflectionFunction($callable);
} else {
throw new \RuntimeException(sprintf('Could not resolve reflection for callable "%s".', is_object($callable) ? get_class($callable) : gettype($callable)));
}
}
}
return new BaseCallable($reflection, $object);
}
/**
* Construct
*
* @param object $object
* @param TransformerContextInterface $transformerContext
* @param NormalizerContextInterface $normalizerContext
*
* @throws UnexpectedTypeException
*/
public function __construct($object, TransformerContextInterface $transformerContext = null, NormalizerContextInterface $normalizerContext = null)
{
if (!is_object($object)) {
throw UnexpectedTypeException::create($object, 'object');
}
$this->action = self::ACTION_TRANSFORM | self::ACTION_NORMALIZE;
$this->object = $object;
}
/**
* {@inheritDoc}
*/
public function recreate($className, $data)
{
if (!is_array($data)) {
throw UnexpectedTypeException::create($data, 'array');
}
if (empty($data['serialized'])) {
throw new ObjectRecreateException('Missing requires parameter "serialized".');
}
$object = unserialize($data['serialized']);
return $object;
}
/**
* {@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}
*/
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 normalize($object, ContextInterface $context = null)
{
if (!is_object($object)) {
throw UnexpectedTypeException::create($object, 'object');
}
if (!$context) {
$context = new Context();
}
$normalizer = $this->getNormalizerForClass(get_class($object));
if ($normalizer instanceof ModelNormalizerManagerAwareInterface) {
$normalizer->setModelNormalizerManager($this);
}
return $normalizer->normalize($object, $context);
}
/**
* {@inheritDoc}
*/
public function transform($object, ContextInterface $context = null)
{
if (!is_object($object)) {
throw UnexpectedTypeException::create($object, 'object');
}
if (!$context) {
$context = new Context();
}
$transformer = $this->getTransformerForClass($object);
if ($transformer instanceof ModelTransformerManagerAwareInterface) {
$transformer->setModelTransformerManager($this);
}
$transformed = $transformer->transform($object, $context);
return $transformed;
}
/**
* {@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 vote(Rule $rule, array $attributes = array())
{
if (!$rule instanceof CallbackRule) {
throw UnexpectedTypeException::create($rule, CallbackRule::class);
}
$arguments = $rule->getArguments();
foreach ($arguments as $key => $value) {
$arguments[$key] = $this->transformParameter($this->expressionLanguage, $value, $attributes);
}
$result = call_user_func_array($rule->getCallback(), $arguments);
if ($result === true) {
return self::ACCESS_GRANTED;
} elseif ($result === false) {
return self::ACCESS_DENIED;
} else {
return self::ACCESS_ABSTAIN;
}
}
/**
* {@inheritDoc}
*/
public function vote(Rule $rule, array $attributes = array())
{
if (!$rule instanceof RoleRule) {
throw UnexpectedTypeException::create($rule, RoleRule::class);
}
$object = null;
if ($rule->getObject()) {
$object = $this->transformParameter($this->expressionLanguage, $rule->getObject(), $attributes);
if (null !== $object && !is_object($object)) {
throw new RuleVotingException(sprintf('Can not transform object from parameter "%s" for RoleRuleVoter. ' . 'Available keys in attributes: "%s". Returned value: "%s" but this is not object. ' . 'Maybe incorrect evaluate?', $object, implode('", "', array_keys($attributes)), is_scalar($object) ? $object : gettype($object)));
}
}
$status = $this->authorizationChecker->isGranted($rule->getRoles(), $object);
if ($status === true) {
return self::ACCESS_GRANTED;
} elseif ($status === false) {
return self::ACCESS_DENIED;
} else {
return self::ACCESS_ABSTAIN;
}
}
/**
* {@inheritDoc}
*/
public function check($object)
{
if (!is_object($object)) {
throw UnexpectedTypeException::create($object, 'object');
}
if (!$this->isSupported($object)) {
throw new NotSupportedException(sprintf('The object "%s" not supported for check "enabled" status.', get_class($object)));
}
if (!$this->checker->check($object)) {
$code = 0;
if ($object instanceof ExceptionAwareInterface) {
$exception = $object->getExceptionForNotEnabled();
if ($exception instanceof \Exception) {
throw $exception;
}
if ($this->logger) {
$this->logger->warning(sprintf('The method %s::%s should be return \\Exception instance, but returned "%s".', get_class($object), 'getExceptionForNotEnabled', is_object($object) ? get_class($object) : gettype($object)));
}
}
throw new NotEnabledException(sprintf('The object %s::%s not enabled.', get_class($object), spl_object_hash($object)), $code);
}
}
/**
* {@inheritDoc}
*/
public function validateObjectByVarTags($object)
{
if (!is_object($object)) {
throw UnexpectedTypeException::create($object, 'object');
}
$classMetadata = $this->metadataFactory->loadMetadata(get_class($object));
$constraintViolationList = new ConstraintViolationList();
foreach ($classMetadata->getProperties() as $propertyName => $propertyMetadata) {
$availableVarTypes = $propertyMetadata->getTypes();
if (!count($availableVarTypes)) {
continue;
}
$violationListForProperty = $this->validatePropertyValueByTypes($object, $propertyName, $availableVarTypes);
if ($violationListForProperty && count($violationListForProperty)) {
foreach ($violationListForProperty as $violationForProperty) {
// Recreate violation for save property path
$violation = new ConstraintViolation($violationForProperty->getMessage(), $violationForProperty->getMessageTemplate(), $violationForProperty->getMessageParameters(), $violationForProperty->getRoot(), $propertyName, $violationForProperty->getInvalidValue(), $violationForProperty->getMessagePluralization(), $violationForProperty->getCode());
$constraintViolationList->add($violation);
}
}
}
return $constraintViolationList;
}
/**
* {@inheritDoc}
*/
public function notify($object, $onEvent = null)
{
if (!is_object($object)) {
throw UnexpectedTypeException::create($object, 'object');
}
$notifyClass = get_class($object);
if (!$this->supportsObject($object)) {
throw new ClassNotSupportedException(sprintf('The object instance "%s" not supports send notification with event "%s".', $notifyClass, $onEvent ? $onEvent : 'NULL'));
}
$classMetadata = $this->metadataFactory->loadMetadata($notifyClass);
$metadata = $this->getNotificationMetadataForEvent($classMetadata, $onEvent, $notifyClass);
$notification = $this->createNotification($metadata, $object);
$this->senderStrategyManager->getStrategy($metadata->getStrategy())->sendNotification($this->sender, $notification);
}
/**
* Process transform object response
*
* @param ObjectResponse $objectResponse
*
* @return Response
*/
private function doTransformObjectResponse(ObjectResponse $objectResponse)
{
$responseData = $objectResponse;
if ($objectResponse->isActionTransform()) {
try {
$responseData = $this->transformerManager->transform($responseData->getObject(), $objectResponse->getTransformerContext());
if (!is_object($responseData)) {
throw UnexpectedTypeException::create($responseData, 'object');
}
} catch (TransformerUnsupportedObjectException $e) {
throw new \RuntimeException(sprintf('Can not transform object with class "%s".', get_class($objectResponse)), 0, $e);
}
}
try {
$responseData = $this->normalizerManager->normalize($responseData instanceof ObjectResponse ? $responseData->getObject() : $responseData, $objectResponse->getNormalizerContext());
if (!is_array($responseData)) {
throw UnexpectedTypeException::create($responseData, 'array');
}
} catch (NormalizerUnsupportedObjectException $e) {
throw new \RuntimeException(sprintf('Can not normalize object with class "%s".', get_class($responseData)), 0, $e);
}
if ($objectResponse->isEmptyResponse()) {
$response = new EmptyResponse($responseData, $objectResponse->getHttpStatusCode());
} else {
$response = new Response($responseData, $objectResponse->getHttpStatusCode());
}
return $response;
}
/**
* Map process
*
* @param object $object
* @param array $parameters
* @param string $group
* @param array $paths
*
* @return object
*
* @throws MapException
* @throws ObjectNotSupportedException
*/
protected function doMap($object, array $parameters, $group, array $paths)
{
if (!is_object($object)) {
throw UnexpectedTypeException::create($object, 'object');
}
$metadata = $this->metadataFactory->load($object, $group);
if (!$metadata) {
throw new ObjectNotSupportedException(sprintf('The object with class "%s" not supported for mapping in group "%s".', get_class($object), $group));
}
$strategy = $this->strategyManager->getStrategy($metadata->getStrategy());
foreach ($metadata->getProperties() as $propertyMetadata) {
if (!isset($parameters[$propertyMetadata->getFieldName()])) {
// Not found parameter for property
continue;
}
// Add path name to paths stack
$paths[] = $propertyMetadata->getFieldName();
$value = $parameters[$propertyMetadata->getFieldName()];
if ($propertyMetadata->getCollectionMetadata()) {
// Map as new collection
$value = $this->doMapCollection($propertyMetadata, $value, $group, $paths);
} else {
if ($propertyMetadata->getClass()) {
// Map as new model
$value = $this->doMapNewObject($propertyMetadata, $value, $group, $paths);
}
}
$strategy->map($propertyMetadata, $object, $value);
// Pop path name from paths stack
array_pop($paths);
}
return $object;
}
/**
* {@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;
}
