getValue() public method

public getValue ( $objectOrArray, $propertyPath )
 public function renderBlock(\Twig_Template $template, ColumnInterface $column, $object, $context, $blocks)
 {
     try {
         $value = $this->accessor->getValue($object, $column->getName());
     } catch (ExceptionInterface $exception) {
         $value = null;
     }
     $block = 'crudify_field_' . $column->getType();
     // check if the block exists
     $hasBlock = false;
     if (!isset($blocks[$block])) {
         $current = $template;
         do {
             if ($current->hasBlock($block)) {
                 break;
             }
             $current = $current->getParent($context);
         } while ($current instanceof \Twig_Template);
         if ($current instanceof \Twig_Template) {
             $hasBlock = true;
         }
     } else {
         $hasBlock = true;
     }
     if ($hasBlock) {
         $context['value'] = $value;
         $context['definition'] = $column->getParent()->getParent();
         $context['column'] = $column;
         $context['object'] = $object;
         $result = $template->renderBlock($block, $context, $blocks);
     } else {
         $result = htmlspecialchars((string) $value, ENT_QUOTES | ENT_SUBSTITUTE, 'utf-8');
     }
     return $result;
 }
 /**
  * @param object     $entity
  * @param Constraint $constraint
  *
  * @throws UnexpectedTypeException
  * @throws ConstraintDefinitionException
  */
 public function validate($entity, Constraint $constraint)
 {
     if (!$constraint instanceof HasEnabledEntity) {
         throw new UnexpectedTypeException($constraint, __NAMESPACE__ . '\\HasEnabledEntity');
     }
     $enabled = $this->accessor->getValue($entity, $constraint->enabledPath);
     if ($enabled === true) {
         return;
     }
     $objectManager = $this->getProperObjectManager($constraint->objectManager, $entity);
     $this->ensureEntityHasProvidedEnabledField($objectManager, $entity, $constraint->enabledPath);
     $criteria = array($constraint->enabledPath => true);
     $repository = $objectManager->getRepository(get_class($entity));
     $results = $repository->{$constraint->repositoryMethod}($criteria);
     /* If the result is a MongoCursor, it must be advanced to the first
      * element. Rewinding should have no ill effect if $result is another
      * iterator implementation.
      */
     if ($results instanceof \Iterator) {
         $results->rewind();
     } elseif (is_array($results)) {
         reset($results);
     }
     if ($this->isLastEnabledEntity($results, $entity)) {
         $errorPath = null !== $constraint->errorPath ? $constraint->errorPath : $constraint->enabledPath;
         $this->context->addViolationAt($errorPath, $constraint->message);
     }
 }
 /**
  * @param FormView $formView
  * @param array    $data
  *
  * @return FormView
  */
 public function formAttributes(FormView $formView, array $data)
 {
     $formView = clone $formView;
     foreach ($data as $key => $value) {
         $path = 'children[' . str_replace('.', '].children[', $key) . ']';
         if (false === $this->accessor->isReadable($formView, $path)) {
             continue;
         }
         /** @var FormView $field */
         $field = $this->accessor->getValue($formView, $path);
         if (false === $field instanceof FormView) {
             throw new \RuntimeException("Cannot set form attribute: {$key} is not a FormView instance");
         }
         if (is_string($value)) {
             $value = ["class" => " {$value}"];
         }
         if (false === isset($field->vars['attr'])) {
             $field->vars['attr'] = [];
         }
         foreach ($value as $name => $attribute) {
             if (isset($field->vars['attr'][$name]) && " " === substr($attribute, 0, 1)) {
                 $attribute = $field->vars['attr'][$name] . $attribute;
             }
             $field->vars['attr'][$name] = trim($attribute);
         }
     }
     return $formView;
 }
 /**
  * @param object $entity
  * @param string $field
  * @param string $locale
  * @param mixed $fieldData
  * @throws \Bigfoot\Bundle\CoreBundle\Exception\InvalidArgumentException
  */
 public function translate($entity, $field, $locale, $fieldData)
 {
     $em = $this->em;
     $meta = $em->getClassMetadata(get_class($entity));
     $listener = $this->getTranslatableListener();
     $persistDefaultLocaleTransInEntity = $listener->getPersistDefaultLocaleTranslation();
     if (is_object($entity)) {
         $entityClass = $entity instanceof Proxy ? get_parent_class($entity) : get_class($entity);
     } else {
         throw new InvalidArgumentException('Argument 1 passed to TranslationRepository::translate must be an object');
     }
     $reflectionClass = new \ReflectionClass($entityClass);
     $entityTranslationClass = $this->isPersonnalTranslationRecursive($reflectionClass)->class;
     if ($locale === $listener->getTranslatableLocale($entity, $meta)) {
         $meta->getReflectionProperty($field)->setValue($entity, $fieldData);
         $em->persist($entity);
     } elseif (!$persistDefaultLocaleTransInEntity && $locale === $listener->getDefaultLocale()) {
         $trans = new $entityTranslationClass($locale, $field, $fieldData);
         $listener->setTranslationInDefaultLocale(spl_object_hash($entity), $field, $trans);
     } else {
         $translationClassRepository = $this->em->getRepository($entityTranslationClass);
         $meta = $em->getClassMetadata(get_class($entity));
         $identifier = $meta->getSingleIdentifierFieldName();
         $translation = null;
         if ($entity && $this->propertyAccessor->getValue($entity, $identifier)) {
             $translation = $translationClassRepository->findOneBy(array('locale' => $locale, 'field' => $field, 'object' => $entity));
         }
         if ($translation) {
             $translation->setContent($fieldData);
         } elseif ($fieldData !== null) {
             $entity->addTranslation(new $entityTranslationClass($locale, $field, $fieldData));
         }
     }
 }
 /**
  * {@inheritdoc}
  */
 public function transform($value)
 {
     if (null === $value) {
         return null;
     }
     if (!is_array($value) && !$value instanceof \Traversable) {
         throw new UnexpectedTypeException($value, 'array or Traversable');
     }
     $result = [LocalizedFallbackValueCollectionType::FIELD_VALUES => [], LocalizedFallbackValueCollectionType::FIELD_IDS => []];
     foreach ($value as $localizedFallbackValue) {
         /** @var LocalizedFallbackValue $localizedFallbackValue */
         $locale = $localizedFallbackValue->getLocale();
         if ($locale) {
             $key = $locale->getId();
         } else {
             $key = 0;
         }
         $fallback = $localizedFallbackValue->getFallback();
         if ($fallback) {
             $value = new FallbackType($fallback);
         } else {
             $value = $this->propertyAccessor->getValue($localizedFallbackValue, $this->field);
         }
         $result[LocalizedFallbackValueCollectionType::FIELD_VALUES][$key ?: null] = $value;
         $result[LocalizedFallbackValueCollectionType::FIELD_IDS][$key] = $localizedFallbackValue->getId();
     }
     return $result;
 }
 /**
  * @param AttributeDefaultValue|null $defaultValue
  * @param string $field
  * @return mixed
  */
 protected function getDefaultValueByField($defaultValue, $field)
 {
     if ($defaultValue) {
         return $this->propertyAccessor->getValue($defaultValue, $field);
     } else {
         return null;
     }
 }
 /**
  * {@inheritdoc}
  */
 public function convertItem($item)
 {
     $result = [];
     foreach ($this->fields as $field) {
         $result[$field] = $this->accessor->getValue($item, $field);
     }
     return $result;
 }
示例#8
0
 function it_should_not_add_violation_if_stock_is_sufficient(PropertyAccessor $propertyAccessor, InventoryUnitInterface $inventoryUnit, StockableInterface $stockable, AvailabilityCheckerInterface $availabilityChecker)
 {
     $propertyAccessor->getValue($inventoryUnit, 'stockable')->willReturn($stockable);
     $propertyAccessor->getValue($inventoryUnit, 'quantity')->willReturn(1);
     $availabilityChecker->isStockSufficient($stockable, 1)->willReturn(true);
     $constraint = new InStock();
     $this->validate($inventoryUnit, $constraint);
 }
示例#9
0
 /**
  * Applies the given mapping on a given object or array.
  *
  * @param  object|array $raw         The input object or array
  * @param  array        $mapping     The mapping
  * @param  object|array $transformed The output object or array.
  * @return array
  */
 public function transform($raw, array $mapping, $transformed = [])
 {
     foreach ($mapping as $destination => $source) {
         $value = $this->propertyAccessor->isReadable($raw, $source) ? $this->propertyAccessor->getValue($raw, $source) : null;
         $this->propertyAccessor->setValue($transformed, $destination, $value);
     }
     return $transformed;
 }
示例#10
0
 private function processResults($entities, $targetEntityConfig)
 {
     $results = array();
     foreach ($entities as $entity) {
         $results[] = array('id' => $this->propertyAccessor->getValue($entity, $targetEntityConfig['primary_key_field_name']), 'text' => (string) $entity);
     }
     return $results;
 }
 /**
  * @inheritdoc
  */
 public function transform($value)
 {
     if (null === $value) {
         return [];
     }
     $text = is_null($this->property) ? (string) $value : $this->propertyAccessor->getValue($value, $this->property);
     $identifier = $this->propertyAccessor->getValue($value, $this->metadata->getIdentifier()[0]);
     return [$identifier ?: $text => $text];
 }
 /**
  * {@inheritdoc}
  */
 public function &get(&$node, $singlePath)
 {
     if (!$singlePath || !$this->isReadable($node, $singlePath)) {
         throw new InvalidPathException(sprintf('Path %s is not readable', $singlePath));
     }
     // Only variables may be returned as reference
     $value = $this->propertyAccess->getValue($node, $singlePath);
     return $value;
 }
 /**
  * @inheritdoc
  */
 public function resolve($func)
 {
     if (!is_string($func)) {
         return null;
     }
     $propertyPath = new PropertyPath($func);
     return function ($item) use($propertyPath) {
         return $this->propertyAccessor->getValue($item, $propertyPath);
     };
 }
示例#14
0
 protected function copyTranslatableEntity(LocaleAwareInterface $entity, LocaleInterface $targetLocale)
 {
     $duplicate = clone $entity;
     foreach ($entity->getCopyingSensitiveProperties() as $propertyName) {
         $value = sprintf('%s-%s', $this->propertyAccessor->getValue($entity, $propertyName), $targetLocale->getCode());
         $this->propertyAccessor->setValue($duplicate, $propertyName, $value);
         $duplicate->setLocale($targetLocale->getCode());
         $this->entityManager->persist($duplicate);
     }
 }
示例#15
0
 /**
  * @param mixed $item
  *
  * @return bool
  */
 public function filter($item)
 {
     $filename = $this->property === null ? $item : $this->accessor->getValue($item, $this->property);
     foreach ($this->extensions as $extension) {
         if (preg_match(sprintf('/\\.%s/', $extension), $filename) === 1) {
             return true;
         }
     }
     return false;
 }
示例#16
0
 private function duplicateTranslatableEntity(LocaleAwareInterface $entity, array $properties, LocaleInterface $targetLocale)
 {
     $duplicate = clone $entity;
     foreach ($properties as $propertyName) {
         $value = sprintf('%s-%s', $this->propertyAccessor->getValue($entity, $propertyName), $targetLocale->getCode());
         $this->propertyAccessor->setValue($duplicate, $propertyName, $value);
         $duplicate->setLocale($targetLocale->getCode());
         $this->doctrineHelper->getEntityManager()->persist($duplicate);
     }
 }
示例#17
0
 /**
  * {@inheritdoc}
  */
 public function setOrigin(OriginAwareInterface $originAware, $origin)
 {
     if (!is_object($origin)) {
         throw new UnexpectedTypeException($origin, 'object');
     }
     if (null === ($id = $this->accessor->getValue($origin, $this->identifier))) {
         throw new \InvalidArgumentException(sprintf('Origin %s is not set.', $this->identifier));
     }
     $originAware->setOriginId($id)->setOriginType(get_class($origin));
 }
 /**
  * @param object $object
  *
  * @return array
  */
 public function getEntityContactData($object)
 {
     $activityContactConfigs = $this->getEntityActivityContactFields($object);
     return array_reduce($activityContactConfigs, function ($carry, ConfigInterface $item) use($object) {
         /** @var FieldConfigId $fieldConfigId */
         $fieldConfigId = $item->getId();
         $fieldName = $fieldConfigId->getFieldName();
         $carry[$fieldName] = $this->propertyAccessor->getValue($object, $fieldName);
         return $carry;
     }, []);
 }
 /**
  * @inheritdoc
  */
 public function transform($value)
 {
     if (is_null($value) || count($value) === 0) {
         return array();
     }
     $data = array();
     foreach ($value as $item) {
         $text = is_null($this->property) ? (string) $item : $this->propertyAccessor->getValue($item, $this->property);
         $identifier = $this->propertyAccessor->getValue($item, $this->metadata->getIdentifier()[0]);
         $data[$identifier ?: $text] = $text;
     }
     return $data;
 }
示例#20
0
 /**
  * {@inheritdoc}
  */
 public function validate($object, $property)
 {
     $this->validators = $this->fixValidators($this->validators);
     $errors = array();
     $value = $this->propertyAccessor->getValue($object, $property);
     foreach ($this->validators as $validator) {
         $validatorErrors = $validator->validate($value);
         if ($validatorErrors) {
             $errors = array_merge($validatorErrors, $errors);
         }
     }
     return $errors;
 }
示例#21
0
 /**
  * {@inheritdoc}
  */
 public function __invoke($input)
 {
     if (!is_object($input)) {
         throw new UnexpectedTypeException($input, 'object');
     }
     if (null === $this->propertyPath && !method_exists($input, '__toString')) {
         throw new \RuntimeException();
     }
     if (null === $this->propertyPath) {
         return (string) $input;
     }
     $path = new PropertyPath($this->propertyPath);
     return $this->propertyAccessor->getValue($input, $path);
 }
 /**
  * @param $entity
  */
 private function persistAllAssociations($entity)
 {
     $meta = $this->em->getClassMetadata(get_class($entity));
     foreach ($meta->getAssociationMappings() as $mapping) {
         $child = $this->accessor->getValue($entity, $mapping['fieldName']);
         if (null === $child) {
             continue;
         }
         if ($this->isCollection($mapping)) {
             $this->persistCollection($child);
         } else {
             $this->persistEntity($child);
         }
     }
 }
示例#23
0
 /**
  * {@inheritdoc}
  */
 public function buildColumn(ColumnInterface $column, array $options)
 {
     $dataProvider = $options['data_provider'];
     $parentDataProvider = $options['parent_data_provider'];
     if (!$dataProvider instanceof \Closure) {
         $dataProvider = $parentDataProvider ?: function ($data) use($column, $dataProvider) {
             static $path;
             if (null === $path) {
                 $path = $this->createDataProviderPath($column, $data, $dataProvider);
             }
             return $this->propertyAccessor->getValue($data, $path);
         };
     }
     $column->setDataProvider($dataProvider);
 }
 /**
  * {@inheritdoc}
  */
 public function resolveParameter($name, $object)
 {
     $class = get_class($object);
     switch (true) {
         case isset($this->mapping[$class][$name]):
             $path = $this->mapping[$class][$name];
             break;
         case isset($this->mapping[$class]['_fallback']):
             $path = $this->mapping[$class]['_fallback'];
             break;
         default:
             $path = $name;
     }
     return (string) $this->propertyAccessor->getValue($object, $path);
 }
 /**
  * @param Collection        $collection
  * @param ConfigIdInterface $fieldConfig
  *
  * @return array
  */
 protected function getValueForCollection(Collection $collection, ConfigIdInterface $fieldConfig)
 {
     $extendConfig = $this->extendProvider->getConfigById($fieldConfig);
     $titleFieldName = $extendConfig->get('target_title');
     $value = $this->getEntityRouteOptions($extendConfig->get('target_entity'));
     $values = [];
     $priorities = [];
     /** @var object $item */
     foreach ($collection as $item) {
         $value['route_params']['id'] = $item->getId();
         $title = [];
         foreach ($titleFieldName as $fieldName) {
             $title[] = $this->propertyAccessor->getValue($item, $fieldName);
         }
         $values[] = ['id' => $item->getId(), 'link' => $value['route'] ? $this->router->generate($value['route'], $value['route_params']) : false, 'title' => implode(' ', $title)];
         if ($item instanceof PriorityItem) {
             $priorities[] = $item->getPriority();
         }
     }
     // sort values by priority if needed
     if (!empty($priorities) && count($priorities) === count($values)) {
         array_multisort($priorities, $values);
     }
     $value['values'] = $values;
     return $value;
 }
示例#26
0
 protected function getRowSpecialParams($row, $isAjax = true)
 {
     $params = array();
     $attr = $this->options['row_attr'];
     // Id parameter:
     if (isset($attr['id']) && $attr['id'] !== null) {
         $paramName = $isAjax ? 'DT_RowId' : 'id';
         try {
             $params[$paramName] = $this->name . '_row_' . $this->propertyAccessor->getValue($row, $attr['id']);
         } catch (\Exception $e) {
             unset($params[$paramName], $attr['id']);
         }
     }
     // Class parameter:
     if (isset($attr['class']) && $attr['class'] !== null) {
         $paramName = $isAjax ? 'DT_RowClass' : 'class';
         $params[$paramName] = (string) $attr['class'];
         unset($attr['class']);
     }
     // Add custom attributes to row:
     if (is_array($attr)) {
         foreach ($attr as $name => $value) {
             if (is_callable($value)) {
                 $params['_rowAttr'][$name] = $value($row);
             } else {
                 $params['_rowAttr'][$name] = $value;
             }
         }
     }
     if ($isAjax) {
         $params['_isAjax'] = true;
     }
     return $params;
 }
示例#27
0
 /**
  * {@inheritdoc}
  */
 public function validate($value, Constraint $constraint)
 {
     /** @var InStock $constraint */
     Assert::isInstanceOf($constraint, InStock::class);
     $stockable = $this->accessor->getValue($value, $constraint->stockablePath);
     if (null === $stockable) {
         return;
     }
     $quantity = $this->accessor->getValue($value, $constraint->quantityPath);
     if (null === $quantity) {
         return;
     }
     if (!$this->availabilityChecker->isStockSufficient($stockable, $quantity)) {
         $this->context->addViolation($constraint->message, ['%stockable%' => $stockable->getInventoryName()]);
     }
 }
示例#28
0
 /**
  * {@inheritDoc}
  */
 public function buildForm(FormBuilderInterface $builder, array $options)
 {
     $admin = clone $this->getAdmin($options);
     if ($admin->hasParentFieldDescription()) {
         $admin->getParentFieldDescription()->setAssociationAdmin($admin);
     }
     if ($options['delete'] && $admin->isGranted('DELETE')) {
         if (!array_key_exists('translation_domain', $options['delete_options']['type_options'])) {
             $options['delete_options']['type_options']['translation_domain'] = $admin->getTranslationDomain();
         }
         $builder->add('_delete', $options['delete_options']['type'], $options['delete_options']['type_options']);
     }
     // hack to make sure the subject is correctly set
     // https://github.com/sonata-project/SonataAdminBundle/pull/2076
     if ($builder->getData() === null) {
         $p = new PropertyAccessor(false, true);
         try {
             $subject = $p->getValue($admin->getParentFieldDescription()->getAdmin()->getSubject(), $this->getFieldDescription($options)->getFieldName() . $options['property_path']);
             $builder->setData($subject);
         } catch (NoSuchIndexException $e) {
             // no object here
         }
     }
     $admin->setSubject($builder->getData());
     $admin->defineFormBuilder($builder);
     $builder->addModelTransformer(new ArrayToModelTransformer($admin->getModelManager(), $admin->getClass()));
 }
 /**
  * {@inheritdoc}
  */
 public function invoke(callable $callable, $requestObject)
 {
     /** @var Attribute $attributeAnnotation */
     $attributeAnnotation = $this->annotationReader->getMethodAnnotation(ReflectionFunctionFactory::createReflectionMethodFromCallable($callable), Attribute::class);
     $attributeName = $attributeAnnotation->name;
     $attributeValue = $this->propertyAccessor->getValue($requestObject, $attributeAnnotation->valueAt);
     $userId = $this->userProvider->getUserId();
     if (!is_array($attributeValue) && !$this->guard->isGranted($userId, $attributeName, $attributeValue)) {
         throw new AccessDeniedException();
     }
     if (is_array($attributeValue)) {
         $attributeValue = $this->guard->filterGranted($userId, $attributeName, $attributeValue);
         $this->propertyAccessor->setValue($requestObject, $attributeAnnotation->valueAt, $attributeValue);
     }
     return $this->methodInvoker->invoke($callable, $requestObject);
 }
示例#30
0
 /**
  * {@inheritdoc}
  */
 public function getValue($objectOrArray, $propertyPath)
 {
     try {
         return parent::getValue($objectOrArray, $propertyPath);
     } catch (Exception\NoSuchPropertyException $e) {
         $tags = array();
         if (!$objectOrArray instanceof ProductInterface) {
             return $tags;
         }
         $propertyPath = strtolower((string) $propertyPath);
         foreach ($objectOrArray->getAvailableVariants() as $variant) {
             foreach ($variant->getOptions() as $option) {
                 if ($propertyPath === strtolower($option->getPresentation())) {
                     $tags[] = $option->getValue();
                 }
             }
         }
         foreach ($objectOrArray->getAttributes() as $attribute) {
             if ($propertyPath === strtolower(str_replace(' ', '_', $attribute->getPresentation()))) {
                 $tags[] = $attribute->getValue();
             }
         }
         return array_values(array_unique($tags));
     }
 }