PHP ParamConverter::getOptions方法代码示例

 /**
  * @param ParamConverter $configuration
  * @return bool
  */
 protected function checkFailureOnValidationError(ParamConverter $configuration)
 {
     if (isset($configuration->getOptions()['fail_on_validation_error'])) {
         return $configuration->getOptions()['fail_on_validation_error'];
     }
     return $this->failOnValidationError;
 }

 /**
  * @param Request        $request
  * @param ParamConverter $configuration
  * @return string
  */
 protected function getRequestAttributeName(Request $request, ParamConverter $configuration)
 {
     $param = $configuration->getName();
     if (array_key_exists('id', $configuration->getOptions())) {
         $param = $configuration->getOptions()['id'];
     }
     return $param;
 }

 public function apply(Request $request, ParamConverter $configuration)
 {
     if ($request->isMethod('POST') && !empty($configuration->getOptions()['request_path'])) {
         $requestPath = $configuration->getOptions()['request_path'];
         $request->attributes->set($requestPath, $request->request->get($requestPath));
     } elseif ($request->isMethod('GET') && !empty($configuration->getOptions()['query_path'])) {
         $queryPath = $configuration->getOptions()['query_path'];
         $request->attributes->set($queryPath, $request->query->get($queryPath));
     }
     return parent::apply($request, $configuration);
 }

 public function it_supports_translatable_classes(ParamConverter $paramConverter, TranslatableMetadata $translatableMetadata)
 {
     $paramConverter->getOptions()->willReturn(array());
     $paramConverter->getClass()->willReturn('TranslatableEntity');
     $translatableMetadata->hasTranslatableProperties()->willReturn(true);
     $this->supports($paramConverter)->shouldReturn(true);
 }

 /**
  * execute
  *
  * @param Request              $request
  * @param SensioParamConverter $configuration
  *
  * @return bool|mixed
  */
 public function execute(Request $request, SensioParamConverter $configuration)
 {
     $id = $request->attributes->get('id');
     $locale = $request->attributes->get('locale');
     $url = $request->attributes->get('url');
     $name = $configuration->getName();
     $options = $configuration->getOptions();
     $resolvedClass = $configuration->getClass();
     $method = $request->getMethod();
     $rawPayload = $request->getContent();
     switch (true) {
         case 'GET' === $method:
             $convertedValue = $this->loadEntity($resolvedClass, $id, $locale, $url);
             break;
         case 'DELETE' === $method:
             $convertedValue = $this->loadEntity($resolvedClass, $id, $locale, $url);
             break;
         case 'PUT' === $method:
             $payload = array_merge(array('id' => $id), json_decode($rawPayload, true));
             $convertedValue = $this->updateEntity($resolvedClass, json_encode($payload));
             break;
         case 'POST' === $method:
             $convertedValue = $this->updateEntity($resolvedClass, $rawPayload);
             break;
     }
     return $convertedValue;
 }

 /**
  * Stores the object in the request.
  *
  * @param Request        $request       The request
  * @param ParamConverter $configuration Contains the name, class and options of the object
  *
  * @return boolean True if the object has been successfully set, else false
  *
  * @throws UnsupportedMediaTypeHttpException
  * @throws BadRequestHttpException
  */
 protected function execute(Request $request, ParamConverter $configuration)
 {
     $options = (array) $configuration->getOptions();
     if (isset($options['deserializationContext']) && is_array($options['deserializationContext'])) {
         $context = array_merge($this->context, $options['deserializationContext']);
     } else {
         $context = $this->context;
     }
     if ($this->serializer instanceof SerializerInterface) {
         $context = $this->configureDeserializationContext($this->getDeserializationContext(), $context);
     }
     try {
         $object = $this->serializer->deserialize($request->getContent(), $configuration->getClass(), $request->getContentType(), $context);
     } catch (UnsupportedFormatException $e) {
         throw new UnsupportedMediaTypeHttpException($e->getMessage());
     } catch (JMSSerializerException $e) {
         throw new BadRequestHttpException($e->getMessage());
     } catch (SymfonySerializerException $e) {
         throw new BadRequestHttpException($e->getMessage());
     }
     $request->attributes->set($configuration->getName(), $object);
     if (null !== $this->validator) {
         $validatorOptions = $this->getValidatorOptions($options);
         $request->attributes->set($this->validationErrorsArgument, $this->validator->validate($object, $validatorOptions['groups'], $validatorOptions['traverse'], $validatorOptions['deep']));
     }
     return true;
 }

 /**
  * {@inheritdoc}
  */
 public function apply(Request $request, ParamConverter $configuration)
 {
     $options = (array) $configuration->getOptions();
     if (isset($options['deserializationContext']) && is_array($options['deserializationContext'])) {
         $arrayContext = array_merge($this->context, $options['deserializationContext']);
     } else {
         $arrayContext = $this->context;
     }
     $this->configureContext($context = new Context(), $arrayContext);
     try {
         $object = $this->serializer->deserialize($request->getContent(), $configuration->getClass(), $request->getContentType(), $context);
     } catch (UnsupportedFormatException $e) {
         throw new UnsupportedMediaTypeHttpException($e->getMessage(), $e);
     } catch (JMSSerializerException $e) {
         throw new BadRequestHttpException($e->getMessage(), $e);
     } catch (SymfonySerializerException $e) {
         throw new BadRequestHttpException($e->getMessage(), $e);
     }
     $request->attributes->set($configuration->getName(), $object);
     if (null !== $this->validator) {
         $validatorOptions = $this->getValidatorOptions($options);
         $errors = $this->validator->validate($object, null, $validatorOptions['groups']);
         $request->attributes->set($this->validationErrorsArgument, $errors);
     }
     return true;
 }

 /**
  * {@inheritdoc}
  *
  * @throws NotFoundHttpException When invalid date given
  */
 public function apply(Request $request, ParamConverter $configuration)
 {
     $param = $configuration->getName();
     if (!$request->attributes->has($param)) {
         return false;
     }
     $options = $configuration->getOptions();
     $value = $request->attributes->get($param);
     if (!$value && $configuration->isOptional()) {
         return false;
     }
     if (isset($options['format'])) {
         $date = DateTime::createFromFormat($options['format'], $value);
         if (!$date) {
             throw new NotFoundHttpException('Invalid date given.');
         }
     } else {
         if (false === strtotime($value)) {
             throw new NotFoundHttpException('Invalid date given.');
         }
         $date = new DateTime($value);
     }
     $request->attributes->set($param, $date);
     return true;
 }

 /**
  * {@inheritdoc}
  */
 public function supports(ParamConverter $configuration)
 {
     $options = $configuration->getOptions();
     if (isset($options['allowAnonymous'])) {
         return is_bool($options['allowAnonymous']) ? true : false;
     }
     return true;
 }

 /**
  * {@inheritdoc}
  */
 public function supports(ParamConverter $configuration)
 {
     $options = $configuration->getOptions();
     if (isset($options['multipleIds']) && $options['multipleIds'] === true) {
         return true;
     }
     return false;
 }

 /**
  * {@inheritdoc}
  */
 public function supports(ParamConverter $configuration)
 {
     $options = $configuration->getOptions();
     if (isset($options['authenticatedUser']) && is_bool($options['authenticatedUser'])) {
         return true;
     }
     return false;
 }

 /**
  * @param Request                $request
  * @param ParamConverter $configuration
  *
  * @return bool
  *
  * @throws \LogicException
  * @throws NotFoundHttpException
  * @throws \Exception
  */
 public function apply(Request $request, ParamConverter $configuration)
 {
     $classQuery = $configuration->getClass() . 'Query';
     $classPeer = $configuration->getClass() . 'Peer';
     $this->filters = array();
     $this->exclude = array();
     if (!class_exists($classQuery)) {
         throw new \Exception(sprintf('The %s Query class does not exist', $classQuery));
     }
     $tableMap = $classPeer::getTableMap();
     $pkColumns = $tableMap->getPrimaryKeyColumns();
     if (count($pkColumns) == 1) {
         $this->pk = strtolower($pkColumns[0]->getName());
     }
     $options = $configuration->getOptions();
     // Check route options for converter options, if there are non provided.
     if (empty($options) && $request->attributes->has('_route') && $this->router && $configuration instanceof ParamConverter) {
         $converterOption = $this->router->getRouteCollection()->get($request->attributes->get('_route'))->getOption('propel_converter');
         if (!empty($converterOption[$configuration->getName()])) {
             $options = $converterOption[$configuration->getName()];
         }
     }
     if (isset($options['mapping'])) {
         // We use the mapping for calling findPk or filterBy
         foreach ($options['mapping'] as $routeParam => $column) {
             if ($request->attributes->has($routeParam)) {
                 if ($this->pk === $column) {
                     $this->pk = $routeParam;
                 } else {
                     $this->filters[$column] = $request->attributes->get($routeParam);
                 }
             }
         }
     } else {
         $this->exclude = isset($options['exclude']) ? $options['exclude'] : array();
         $this->filters = $request->attributes->all();
     }
     $this->withs = isset($options['with']) ? is_array($options['with']) ? $options['with'] : array($options['with']) : array();
     // find by Pk
     if (false === ($object = $this->findPk($classQuery, $request))) {
         // find by criteria
         if (false === ($object = $this->findOneBy($classQuery, $request))) {
             if ($configuration->isOptional()) {
                 //we find nothing but the object is optional
                 $object = null;
             } else {
                 throw new \LogicException('Unable to guess how to get a Propel object from the request information.');
             }
         }
     }
     if (null === $object && false === $configuration->isOptional()) {
         throw new NotFoundHttpException(sprintf('%s object not found.', $configuration->getClass()));
     }
     $request->attributes->set($configuration->getName(), $object);
     return true;
 }

 /**
  * Stores the object in the request.
  *
  * @param Request        $request       The request
  * @param ParamConverter $configuration Contains the name, class and options of the object
  *
  * @return bool    True if the object has been successfully set, else false
  */
 public function apply(Request $request, ParamConverter $configuration)
 {
     $options = $configuration->getOptions();
     if (!empty($options['parameters'])) {
         foreach ($options['parameters'] as $parameter) {
             $request->attributes->set($parameter, $request->get($parameter));
         }
     }
     return true;
 }

 private function getOptions(ParamConverter $configuration)
 {
     $options = array_replace(['model' => $configuration->getClass() . 'Model'], $configuration->getOptions());
     if (isset($options['connection'])) {
         $options['session'] = $this->pomm[$options['session']];
     } else {
         $options['session'] = $this->pomm->getDefaultSession();
     }
     return $options;
 }

 /**
  * @see \Sensio\Bundle\FrameworkExtraBundle\Request\ParamConverter\ParamConverterInterface::apply()
  */
 public function apply(Request $request, ParamConverter $configuration)
 {
     $options = $configuration->getOptions();
     $service_id = isset($options['service_id']) ? $options['service_id'] : $this->getServiceIdForClassName($configuration);
     $handler = $this->container->get($service_id);
     $class = $this->handlers[$service_id];
     if (!$handler instanceof FormHandlerInterface || get_class($handler) !== $class) {
         return;
     }
     $request->attributes->set($configuration->getName(), $handler);
 }