/** * Specific annotation evaluation. * * @param Request $request Request * @param Annotation $annotation Annotation * @param ReflectionMethod $method Method * * @return FormAnnotationResolver self Object */ public function evaluateAnnotation(Request $request, Annotation $annotation, ReflectionMethod $method) { /** * Annotation is only laoded if is typeof WorkAnnotation */ if ($annotation instanceof AnnotationForm) { /** * Once loaded Annotation info, we just instanced Service name */ $annotationValue = $annotation->getClass(); /** * Get FormType object given a service name */ $type = class_exists($annotationValue) ? new $annotationValue() : $this->formRegistry->getType($annotationValue)->getInnerType(); /** * Get the parameter name. If not defined, is set as $form */ $parameterName = $annotation->getName() ?: $this->defaultName; $parameterClass = $this->getParameterType($method, $parameterName, 'Symfony\\Component\\Form\\FormInterface'); /** * Requiring result with calling getBuiltObject(), set as request * attribute desired element */ $request->attributes->set($parameterName, $this->getBuiltObject($request, $this->formFactory, $annotation, $parameterClass, $type)); } return $this; }
/** * {@inheritdoc} */ public function createBuilderForProperty($class, $property, $data = null, array $options = array()) { if (null === ($guesser = $this->registry->getTypeGuesser())) { return $this->createNamedBuilder($property, 'Symfony\\Component\\Form\\Extension\\Core\\Type\\TextType', $data, $options); } $typeGuess = $guesser->guessType($class, $property); $maxLengthGuess = $guesser->guessMaxLength($class, $property); $requiredGuess = $guesser->guessRequired($class, $property); $patternGuess = $guesser->guessPattern($class, $property); $type = $typeGuess ? $typeGuess->getType() : 'Symfony\\Component\\Form\\Extension\\Core\\Type\\TextType'; $maxLength = $maxLengthGuess ? $maxLengthGuess->getValue() : null; $pattern = $patternGuess ? $patternGuess->getValue() : null; if (null !== $pattern) { $options = array_replace_recursive(array('attr' => array('pattern' => $pattern)), $options); } if (null !== $maxLength) { $options = array_replace_recursive(array('attr' => array('maxlength' => $maxLength)), $options); } if ($requiredGuess) { $options = array_merge(array('required' => $requiredGuess->getValue()), $options); } // user options may override guessed options if ($typeGuess) { $options = array_merge($typeGuess->getOptions(), $options); } return $this->createNamedBuilder($property, $type, $data, $options); }
/** * @param array $options * * @return array */ private function addDefaultOptions(array $options) { $defaultOptions = []; // hack to prevent validation error "The CSRF token is invalid." foreach ($this->formRegistry->getExtensions() as $extension) { foreach ($extension->getTypeExtensions(FormType::class) as $typeExtension) { if ($typeExtension instanceof FormTypeCsrfExtension) { $defaultOptions['csrf_protection'] = false; } } } return array_replace($defaultOptions, $options); }
function it_builds_prototypes_forms_for_calculators(ServiceRegistryInterface $calculatorRegistry, FormBuilder $builder, FormBuilder $flatRateFormBuilder, Form $flatRateForm, CalculatorInterface $flatRateCalculator, FormBuilder $perUnitFormBuilder, Form $perUnitForm, CalculatorInterface $perUnitRateCalculator, FormRegistryInterface $formRegistry) { $builder->add(Argument::any(), Argument::cetera())->willReturn($builder); $builder->addEventSubscriber(Argument::any())->willReturn($builder); $flatRateCalculator->getType()->willReturn('flat_rate'); $perUnitRateCalculator->getType()->willReturn('per_unit_rate'); $calculatorRegistry->all()->willReturn(['flat_rate' => $flatRateCalculator, 'per_unit_rate' => $perUnitRateCalculator]); $flatRateFormBuilder->getForm()->willReturn($flatRateForm); $builder->create('configuration', 'sylius_shipping_calculator_flat_rate')->willReturn($flatRateFormBuilder); $perUnitFormBuilder->getForm()->willReturn($perUnitForm); $builder->create('configuration', 'sylius_shipping_calculator_per_unit_rate')->willReturn($perUnitFormBuilder); $formRegistry->hasType('sylius_shipping_calculator_per_unit_rate')->shouldBeCalled()->willReturn(true); $formRegistry->hasType('sylius_shipping_calculator_flat_rate')->shouldBeCalled()->willReturn(true); $builder->setAttribute('prototypes', ['calculators' => ['flat_rate' => $flatRateForm, 'per_unit_rate' => $perUnitForm], 'rules' => []])->shouldBeCalled(); $this->buildForm($builder, []); }
/** * {@inheritdoc} */ public function buildForm(FormBuilderInterface $builder, array $options) { $builder->addEventSubscriber(new BuildShippingMethodFormSubscriber($this->calculatorRegistry, $builder->getFormFactory(), $this->formRegistry))->addEventSubscriber(new AddCodeFormSubscriber())->add('translations', 'sylius_translations', ['type' => 'sylius_shipping_method_translation', 'label' => 'sylius.form.shipping_method.translations'])->add('category', 'sylius_shipping_category_choice', ['required' => false, 'empty_value' => 'sylius.ui.no_requirement', 'label' => 'sylius.form.shipping_method.category'])->add('categoryRequirement', 'choice', ['choices' => ShippingMethod::getCategoryRequirementLabels(), 'multiple' => false, 'expanded' => true, 'label' => 'sylius.form.shipping_method.category_requirement'])->add('calculator', 'sylius_shipping_calculator_choice', ['label' => 'sylius.form.shipping_method.calculator'])->add('enabled', 'checkbox', ['label' => 'sylius.form.locale.enabled']); $prototypes = ['rules' => [], 'calculators' => []]; /** @var RuleCheckerInterface $checker */ foreach ($this->checkerRegistry->all() as $type => $checker) { $prototypes['rules'][$type] = $builder->create('__name__', $checker->getConfigurationFormType())->getForm(); } /** @var CalculatorInterface $calculator */ foreach ($this->calculatorRegistry->all() as $name => $calculator) { $calculatorTypeName = sprintf('sylius_shipping_calculator_%s', $calculator->getType()); if (!$this->formRegistry->hasType($calculatorTypeName)) { continue; } $prototypes['calculators'][$name] = $builder->create('configuration', $calculatorTypeName)->getForm(); } $builder->setAttribute('prototypes', $prototypes); }
/** * {@inheritdoc} */ public function buildForm(FormBuilderInterface $builder, array $options) { $builder->addEventSubscriber(new BuildShippingMethodFormSubscriber($this->calculatorRegistry, $builder->getFormFactory(), $this->formRegistry))->addEventSubscriber(new AddCodeFormSubscriber())->add('translations', 'a2lix_translationsForms', array('form_type' => 'sylius_shipping_method_translation', 'label' => 'sylius.form.shipping_method.name'))->add('category', 'sylius_shipping_category_choice', array('required' => false, 'label' => 'sylius.form.shipping_method.category'))->add('categoryRequirement', 'choice', array('choices' => ShippingMethod::getCategoryRequirementLabels(), 'multiple' => false, 'expanded' => true, 'label' => 'sylius.form.shipping_method.category_requirement'))->add('calculator', 'sylius_shipping_calculator_choice', array('label' => 'sylius.form.shipping_method.calculator')); $prototypes = array(); $prototypes['rules'] = array(); foreach ($this->checkerRegistry->all() as $type => $checker) { $prototypes['rules'][$type] = $builder->create('__name__', $checker->getConfigurationFormType())->getForm(); } $prototypes['calculators'] = array(); foreach ($this->calculatorRegistry->all() as $name => $calculator) { $calculatorTypeName = sprintf("sylius_shipping_calculator_%s", $calculator->getType()); if (!$this->formRegistry->hasType($calculatorTypeName)) { continue; } $prototypes['calculators'][$name] = $builder->create('configuration', $calculatorTypeName)->getForm(); } $builder->setAttribute('prototypes', $prototypes); }
/** * Add the calculator configuration fields. * * @param FormInterface $form * @param string $calculatorName * @param array $data */ protected function addConfigurationFields(FormInterface $form, $calculatorName, array $data = []) { $calculator = $this->calculatorRegistry->get($calculatorName); $calculatorTypeName = sprintf('sylius_shipping_calculator_%s', $calculator->getType()); if (!$this->formRegistry->hasType($calculatorTypeName)) { return; } $configurationField = $this->factory->createNamed('configuration', $calculatorTypeName, $data, ['auto_initialize' => false]); $form->add($configurationField); }
/** * Wraps a type into a ResolvedFormTypeInterface implementation and connects * it with its parent type. * * @param FormTypeInterface $type The type to resolve. * * @return ResolvedFormTypeInterface The resolved type. */ private function resolveType(FormTypeInterface $type) { $parentType = $type->getParent(); if ($parentType instanceof FormTypeInterface) { $parentType = $this->resolveType($parentType); } elseif (null !== $parentType) { $parentType = $this->registry->getType($parentType); } return $this->resolvedTypeFactory->createResolvedType($type, array(), $parentType); }
private function getFormType($formType) { if (is_string($formType)) { if ($this->formRegistry->hasType($formType)) { $formType = $this->formRegistry->getType($formType); } else { $formType = new $formType(); } } return $formType; }
/** * Wraps a type into a ResolvedFormTypeInterface implementation and connects * it with its parent type. * * @param FormTypeInterface $type The type to resolve. * * @return ResolvedFormTypeInterface The resolved type. */ private function resolveType(FormTypeInterface $type) { $parentType = $type->getParent(); if ($parentType instanceof FormTypeInterface) { $parentType = $this->resolveType($parentType); } elseif (null !== $parentType) { $parentType = $this->registry->getType($parentType); } return $this->resolvedTypeFactory->createResolvedType( $type, // Type extensions are not supported for unregistered type instances, // i.e. type instances that are passed to the FormFactory directly, // nor for their parents, if getParent() also returns a type instance. array(), $parentType ); }
/** * Returns a type by name. * * This methods registers the type extensions from the form extensions. * * @param string $name The name of the type * * @return FormTypeInterface The type * * @throws Exception\FormException if the type can not be retrieved from any extension * * @deprecated Deprecated since version 2.1, to be removed in 2.3. Use * {@link FormRegistryInterface::getType()} instead. */ public function getType($name) { return $this->registry->getType($name)->getInnerType(); }
/** * Returns a new ApiDoc instance with more data. * * @param ApiDoc $annotation * @param Route $route * @param \ReflectionMethod $method * @param DunglasResource $dunglasResource * @return ApiDoc */ protected function extractData(ApiDoc $annotation, Route $route, \ReflectionMethod $method, DunglasResource $dunglasResource = null) { //remove methode OPTIONS $methods = $route->getMethods(); $optionIndex = array_search('OPTIONS', $methods); if ($optionIndex !== false) { unset($methods[$optionIndex]); $route->setMethods($methods); } if (in_array(strtolower($this->versionApi), $this->nelmioDocStandardVersion)) { return parent::extractData($annotation, $route, $method); } // create a new annotation $annotation = clone $annotation; $annotation->addTag($this->versionApi, '#ff0000'); // doc $annotation->setDocumentation($this->commentExtractor->getDocCommentText($method)); // parse annotations $this->parseAnnotations($annotation, $route, $method); $resource = $route->getDefault('_resource'); // route $annotation->setRoute($route); $entityClassInput = $entityClassOutput = null; //section $annotation->setSection($resource); $annotation = $this->addFilters($resource, $annotation, $dunglasResource, $route); if (in_array($annotation->getMethod(), ['POST', 'PUT'])) { $formName = 'api_v2_' . strtolower($dunglasResource->getShortName()); if ($hasFormtype = $this->registry->hasType($formName)) { $type = $this->registry->getType($formName); if ($type instanceof ResolvedFormTypeInterface) { $entityClassInput = get_class($type->getInnerType()); $dunglasResource->initValidationGroups($type->getInnerType()->validationGrp); } } } if ('GET' === $annotation->getMethod()) { $entityClassInput = null; } if (is_null($annotation->getOutput()) || is_array($annotation->getOutput())) { $entityClassOutput = $this->transformerHelper->getEntityClass($resource); } else { $entityClassOutput = $annotation->getOutput(); } if ('DELETE' === $annotation->getMethod()) { $entityClassInput = $entityClassOutput = null; } // input (populates 'parameters' for the formatters) if (null !== ($input = $entityClassInput)) { $normalizedInput = $this->normalizeClassParameter($input, $dunglasResource); $parameters = $this->getParametersParser($normalizedInput, $resource, $dunglasResource, $annotation); if ($hasFormtype && in_array($annotation->getMethod(), ['POST', 'PUT'])) { $parameters = $this->processFormParams($formName, $parameters, $dunglasResource); } $parameters = $this->clearClasses($parameters); $parameters = $this->generateHumanReadableTypes($parameters); if ($annotation->getMethod() === 'POST') { if (isset($parameters['id'])) { unset($parameters['id']); } } if (in_array($annotation->getMethod(), ['PUT', 'PATCH'])) { // All parameters are optional with PUT (update) array_walk($parameters, function ($val, $key) use(&$parameters) { $parameters[$key]['required'] = false; }); } $annotation->setParameters($parameters); } // output (populates 'response' for the formatters) if (null !== ($output = $entityClassOutput)) { $normalizedOutput = $this->normalizeClassParameter($output, $dunglasResource); if (!is_array($annotation->getOutput())) { $response = $this->getParametersParser($normalizedOutput, $resource, $dunglasResource, $annotation, 'Output'); foreach ($response as $key => $params) { if (isset($response[$key]['children'])) { unset($response[$key]['children']); } if ($response[$key]['actualType'] === 'model') { $response[$key]['dataType'] = 'Integer | ' . $response[$key]['dataType']; } } $response = $this->clearClasses($response); $response = $this->generateHumanReadableTypes($response); } else { $response = $this->normalizeArrayParameter($annotation->getOutput()); } $annotation->setResponse($response); $annotation->setResponseForStatusCode($response, $normalizedOutput, 200); } if (count($annotation->getResponseMap()) > 0) { foreach ($annotation->getResponseMap() as $code => $modelName) { if (is_array($modelName)) { continue; } if ('200' === (string) $code && isset($modelName['type']) && isset($modelName['model'])) { /* * Model was already parsed as the default `output` for this ApiDoc. */ continue; } $normalizedModel = $this->normalizeClassParameter($modelName, $dunglasResource); $parameters = array(); $supportedParsers = array(); foreach ($this->getParsers($normalizedModel) as $parser) { if ($parser->supports($normalizedModel)) { $supportedParsers[] = $parser; $parameters = $this->mergeParameters($parameters, $parser->parse($normalizedModel)); } } foreach ($supportedParsers as $parser) { if ($parser instanceof PostParserInterface) { $mp = $parser->postParse($normalizedModel, $parameters); $parameters = $this->mergeParameters($parameters, $mp); } } $parameters = $this->clearClasses($parameters); $parameters = $this->generateHumanReadableTypes($parameters); $annotation->setResponseForStatusCode($parameters, $normalizedModel, $code); } } return $annotation; }