PHP ExecutionContextInterface::getGroup方法代码示例

 /**
  * {@inheritdoc}
  */
 public function validatePropertyValue($objectOrClass, $propertyName, $value, $groups = null)
 {
     $classMetadata = $this->metadataFactory->getMetadataFor($objectOrClass);
     if (!$classMetadata instanceof ClassMetadataInterface) {
         // Cannot be UnsupportedMetadataException because of BC with
         // Symfony < 2.5
         throw new ValidatorException(sprintf('The metadata factory should return instances of ' . '"\\Symfony\\Component\\Validator\\Mapping\\ClassMetadataInterface", ' . 'got: "%s".', is_object($classMetadata) ? get_class($classMetadata) : gettype($classMetadata)));
     }
     $propertyMetadatas = $classMetadata->getPropertyMetadata($propertyName);
     $groups = $groups ? $this->normalizeGroups($groups) : $this->defaultGroups;
     if (is_object($objectOrClass)) {
         $object = $objectOrClass;
         $cacheKey = spl_object_hash($objectOrClass);
         $propertyPath = PropertyPath::append($this->defaultPropertyPath, $propertyName);
     } else {
         // $objectOrClass contains a class name
         $object = null;
         $cacheKey = null;
         $propertyPath = $this->defaultPropertyPath;
     }
     $previousValue = $this->context->getValue();
     $previousObject = $this->context->getObject();
     $previousMetadata = $this->context->getMetadata();
     $previousPath = $this->context->getPropertyPath();
     $previousGroup = $this->context->getGroup();
     foreach ($propertyMetadatas as $propertyMetadata) {
         $this->validateGenericNode($value, $object, $cacheKey . ':' . $propertyName, $propertyMetadata, $propertyPath, $groups, null, TraversalStrategy::IMPLICIT, $this->context);
     }
     $this->context->setNode($previousValue, $previousObject, $previousMetadata, $previousPath);
     $this->context->setGroup($previousGroup);
     return $this;
 }

 /**
  * Creates a validator for the given context.
  *
  * @param ExecutionContextInterface           $context          The execution context
  * @param MetadataFactoryInterface            $metadataFactory  The factory for
  *                                                              fetching the metadata
  *                                                              of validated objects
  * @param ConstraintValidatorFactoryInterface $validatorFactory The factory for creating
  *                                                              constraint validators
  */
 public function __construct(ExecutionContextInterface $context, MetadataFactoryInterface $metadataFactory, ConstraintValidatorFactoryInterface $validatorFactory)
 {
     $this->context = $context;
     $this->defaultPropertyPath = $context->getPropertyPath();
     $this->defaultGroups = array($context->getGroup() ?: Constraint::DEFAULT_GROUP);
     $this->metadataFactory = $metadataFactory;
     $this->validatorFactory = $validatorFactory;
 }

 function it_validates_object($constraint, NewContext $context, ValidatorInterface $validator, ContextualValidatorInterface $contextValidator)
 {
     $constraint->condition = function ($object) {
         return $object->name == 'some name';
     };
     $object = new \stdClass();
     $object->name = 'some name';
     $context->getGroup()->shouldBeCalled();
     $context->getObject()->willReturn($object);
     $context->getValidator()->willReturn($validator);
     $validator->inContext($context)->willReturn($contextValidator);
     $contextValidator->validate($object, $constraint->constraints, Argument::any())->shouldBeCalled();
     $this->initialize($context);
     $this->validate($object, $constraint);
 }

 /**
  * @param ExecutionContextInterface $context
  * @param AttributeInterface        $attribute
  * @param DataInterface             $data
  *
  * @throws Exception
  */
 protected function validateRules(ExecutionContextInterface $context, AttributeInterface $attribute, DataInterface $data)
 {
     if ($attribute->isMultiple()) {
         $valueData = $data->getValuesData($attribute);
     } else {
         $valueData = $data->getValueData($attribute);
     }
     $loader = new BaseLoader();
     foreach ($attribute->getValidationRules() as $validationRule) {
         foreach ($validationRule as $item => $options) {
             $constraint = $loader->newConstraint($item, $options);
             $violations = $context->getValidator()->validate($valueData, $constraint, $context->getGroup());
             /** @var ConstraintViolationInterface $violation */
             foreach ($violations as $violation) {
                 /** @noinspection DisconnectedForeachInstructionInspection */
                 $path = $attribute->getCode();
                 if ($attribute->getType()->isEmbedded()) {
                     if (!$attribute->isMultiple()) {
                         $path .= '.';
                     }
                     $path .= $violation->getPropertyPath();
                 }
                 if ($violation->getMessage()) {
                     $context->buildViolation($violation->getMessage())->atPath($path)->setInvalidValue($valueData)->addViolation();
                 } else {
                     $this->buildAttributeViolation($context, $attribute, strtolower($item), $valueData, $path);
                 }
             }
         }
     }
 }