/** * {@inheritdoc} */ public function configureOptions(OptionsResolver $resolver) { $defaultFieldOptions = ['multiple' => true]; $resolver->setDefaults(['enum_code' => null, 'class' => null, 'field_options' => $defaultFieldOptions, 'operator_choices' => [self::TYPE_IN => $this->translator->trans('oro.filter.form.label_type_in'), self::TYPE_NOT_IN => $this->translator->trans('oro.filter.form.label_type_not_in')]]); $resolver->setNormalizer('class', function (Options $options, $value) { if ($value !== null) { return $value; } if (empty($options['enum_code'])) { throw new InvalidOptionsException('Either "class" or "enum_code" must option must be set.'); } $class = ExtendHelper::buildEnumValueClassName($options['enum_code']); if (!is_a($class, 'Oro\\Bundle\\EntityExtendBundle\\Entity\\AbstractEnumValue', true)) { throw new InvalidOptionsException(sprintf('"%s" must be a child of "%s"', $class, 'Oro\\Bundle\\EntityExtendBundle\\Entity\\AbstractEnumValue')); } return $class; }); // this normalizer allows to add/override field_options options outside $resolver->setNormalizer('field_options', function (Options $options, $value) use(&$defaultFieldOptions) { if (isset($options['class'])) { $nullValue = null; if ($options->offsetExists('null_value')) { $nullValue = $options->offsetGet('null_value'); } $value['choices'] = $this->getChoices($options['class'], $nullValue); } else { $value['choices'] = []; } return array_merge($defaultFieldOptions, $value); }); }
/** * @param OptionsResolver $resolver */ protected function configureOptions(OptionsResolver $resolver) { $resolver->setRequired(['fields', 'associations', 'callbacks']); $fieldsNormalizer = function (Options $options, $fields) { $collection = new Collection\FieldMetadataCollection(); $factory = new FieldMetadataFactory(); foreach ($fields as $fieldName => $parameters) { $fieldMetadata = $factory->create($fieldName, $parameters); $collection->add($fieldMetadata); } return $collection; }; $associationsNormalizer = function (Options $options, $associations) { $collection = new Collection\AssociationMetadataCollection(); $factory = new AssociationMetadataFactory(); foreach ($associations as $associationName => $parameters) { $associationMetadata = $factory->create($associationName, $parameters); $collection->add($associationMetadata); } return $collection; }; $resolver->setNormalizer('fields', $fieldsNormalizer); $resolver->setNormalizer('associations', $associationsNormalizer); $resolver->setDefaults(['fields' => new Collection\FieldMetadataCollection(), 'associations' => new Collection\AssociationMetadataCollection(), 'callbacks' => []]); $resolver->setAllowedTypes('fields', ['array', Collection\FieldMetadataCollection::class]); $resolver->setAllowedTypes('associations', ['array', Collection\AssociationMetadataCollection::class]); $resolver->setAllowedTypes('callbacks', 'array'); }
/** * @param OptionsResolver $resolver * @throws AccessException * @throws UndefinedOptionsException * @throws MissingFamilyException * @throws \UnexpectedValueException * @throws ConstraintDefinitionException * @throws InvalidOptionsException * @throws MissingOptionsException */ public function configureOptions(OptionsResolver $resolver) { $resolver->setDefaults(['required' => true, 'constraints' => new NotBlank()]); $resolver->setRequired(['attribute', 'parent_data']); $resolver->setNormalizer('attribute', function (Options $options, $value) { return VariantType::normalizeVariantAttribute($value); }); $resolver->setNormalizer('parent_data', function (Options $options, $value) { return VariantType::normalizeParentData($options, $value); }); $resolver->setNormalizer('choices', function (Options $options, $value) { $attribute = $options['attribute']; $families = []; /** @var array $variantFamilies */ $variantFamilies = $attribute->getOptions()['variant_families']; foreach ($variantFamilies as $familyCode) { $family = $this->familyConfigurationHandler->getFamily($familyCode); if (!$family instanceof VariantFamily) { throw new \UnexpectedValueException("Variant families in attribute options must be of type VariantFamily, '{$family->getCode()}' is not a variant"); } $families[ucfirst($family)] = $family; } return $families; }); }
private function configureOptions(OptionsResolver $resolver) { $resolver->setRequired(['alias', 'source', 'aggregated', 'paginator_source']); $resolver->setDefaults(['aggregated' => false, 'paginator_source' => '']); $resolver->setNormalizer('aggregated', function (Options $options) { return $this->isAggregateColumn($options['source'], ['SUM', 'GROUP_CONCAT', 'MIN', 'MAX', 'AVG', 'COUNT']); }); $resolver->setNormalizer('paginator_source', function (Options $options) { return $this->normalizePaginatorSource($options); }); }
public function __construct(array $options) { $math = new NativeMath(); $resolver = new OptionsResolver(); $dimensionsNormalizer = new DimensionsNormalizer($math); $resolver->setDefined(['extra_data'])->setDefaults(['currency' => 'USD', 'math' => $math, 'weight_converter' => new WeightConverter($math), 'length_converter' => new LengthConverter($math), 'girth_calculator' => new UspsGirthCalculator($math, $dimensionsNormalizer), 'dimensions_normalizer' => $dimensionsNormalizer, 'extra_data' => null])->setRequired(['export_countries', 'import_countries', 'zone_calculators', 'currency', 'fuel_subcharge', 'math', 'weight_converter', 'length_converter', 'mass_unit', 'dimensions_unit', 'maximum_girth', 'maximum_dimension'])->setAllowedTypes(['export_countries' => 'array', 'import_countries' => 'array', 'zone_calculators' => 'array', 'currency' => 'string', 'math' => MathInterface::class, 'weight_converter' => UnitConverterInterface::class, 'length_converter' => UnitConverterInterface::class, 'girth_calculator' => UspsGirthCalculator::class, 'dimensions_normalizer' => DimensionsNormalizer::class]); $resolver->setNormalizer('import_countries', $this->createImportCountriesNormalizer()); $resolver->setNormalizer('export_countries', $this->createExportCountriesNormalizer()); $resolver->setNormalizer('zone_calculators', $this->createZoneCalculatorsNormalizer()); $this->options = $resolver->resolve($options); }
/** * {@inheritdoc} */ public function configureOptions(OptionsResolver $resolver) { $defaults = array('image_url' => null, 'widget_type' => $this->widgetType, 'widget_width' => '100px', 'widget_height' => '100px', 'select_label' => 'Select image', 'change_label' => 'Change', 'remove_label' => 'Remove'); $ajaxDefaults = array('total_class' => null, 'total_id' => null, 'total_property' => null, 'parent_class' => null, 'parent_id' => null, 'parent_property' => null); $resolver->setDefaults(array('zkFileSettings' => $defaults, 'zkAjaxSettings' => $ajaxDefaults)); $resolver->setNormalizer('zkFileSettings', function (Options $options, $configs) use($defaults) { return array_merge($defaults, $configs); }); $resolver->setNormalizer('zkAjaxSettings', function (Options $options, $configs) use($ajaxDefaults) { return array_merge($ajaxDefaults, $configs); }); }
public function __construct(array $options) { $math = new NativeMath(); $resolver = new OptionsResolver(); $weightConverter = new WeightConverter($math); $lengthConverter = new LengthConverter($math); $dimensionsNormalizer = new DimensionsNormalizer($math); $resolver->setDefined(['extra_data'])->setDefaults(['currency' => 'USD', 'math' => $math, 'weight_converter' => $weightConverter, 'length_converter' => $lengthConverter, 'perimeter_calculator' => new MaximumPerimeterCalculator($math, $dimensionsNormalizer), 'volumetric_weight_calculator' => new IParcelVolumetricWeightCalculator($math, $weightConverter, $lengthConverter), 'dimensions_normalizer' => $dimensionsNormalizer, 'extra_data' => null])->setRequired(['export_countries', 'import_countries', 'zones', 'currency', 'math', 'weight_converter', 'length_converter', 'mass_unit', 'dimensions_unit', 'maximum_perimeter', 'maximum_dimension', 'maximum_weight'])->setAllowedTypes(['export_countries' => 'array', 'import_countries' => 'array', 'zones' => 'array', 'currency' => 'string', 'math' => MathInterface::class, 'weight_converter' => UnitConverterInterface::class, 'length_converter' => UnitConverterInterface::class, 'perimeter_calculator' => MaximumPerimeterCalculator::class, 'volumetric_weight_calculator' => IParcelVolumetricWeightCalculator::class, 'dimensions_normalizer' => DimensionsNormalizer::class]); $resolver->setNormalizer('import_countries', $this->createImportCountriesNormalizer()); $resolver->setNormalizer('export_countries', $this->createExportCountriesNormalizer()); $resolver->setNormalizer('zones', $this->createZonesNormalizer()); $this->options = $resolver->resolve($options); }
public function __construct(array $options) { $math = new NativeMath(); $resolver = new OptionsResolver(); $weightConverter = new WeightConverter($math); $lengthConverter = new LengthConverter($math); $resolver->setDefined(['extra_data'])->setDefaults(['currency' => 'USD', 'math' => $math, 'weight_converter' => $weightConverter, 'length_converter' => $lengthConverter, 'volumetric_weight_calculator' => new DhlVolumetricWeightCalculator($math, $weightConverter, $lengthConverter), 'dimensions_normalizer' => new DimensionsNormalizer($math), 'extra_data' => null])->setRequired(['export_countries', 'import_countries', 'zone_calculators', 'currency', 'math', 'weight_converter', 'length_converter', 'mass_unit', 'dimensions_unit', 'maximum_weight', 'maximum_dimensions'])->setAllowedTypes(['export_countries' => 'array', 'import_countries' => 'array', 'zone_calculators' => 'array', 'currency' => 'string', 'math' => 'Moriony\\Trivial\\Math\\MathInterface', 'weight_converter' => 'Moriony\\Trivial\\Converter\\UnitConverterInterface', 'length_converter' => 'Moriony\\Trivial\\Converter\\UnitConverterInterface', 'volumetric_weight_calculator' => 'EsteIt\\ShippingCalculator\\VolumetricWeightCalculator\\DhlVolumetricWeightCalculator', 'dimensions_normalizer' => 'EsteIt\\ShippingCalculator\\Tool\\DimensionsNormalizer']); $resolver->setNormalizer('import_countries', $this->createImportCountriesNormalizer()); $resolver->setNormalizer('export_countries', $this->createExportCountriesNormalizer()); $resolver->setNormalizer('zone_calculators', $this->createZoneCalculatorsNormalizer()); $resolver->setNormalizer('maximum_dimensions', $this->createDimensionsNormalizer()); $this->options = $resolver->resolve($options); }
public function configureOptions(OptionsResolver $resolver) { $resolver->setDefaults(['id_property' => 'id', 'manager' => null, 'limit' => 20, 'search' => [], 'property' => 'name']); $resolver->setNormalizer('search', function (Options $options, $value) { if (empty($value) && !empty($options['property'])) { $value = [$options['property'] => self::SEARCH_MIDDLE]; } return $value; }); $resolver->setRequired(['class']); $resolver->setNormalizer('manager', function (Options $options, $manager) { return $this->normalize($options, $manager); }); }
/** * {@inheritdoc} */ public function configureOptions(OptionsResolver $resolver) { $resolver->setDefaults(array('operator' => true, 'sort' => true, 'type' => null, 'value_options' => array())); $resolver->setAllowedTypes('value_options', 'array'); $resolver->setNormalizer('type', function (Options $options, $value) { if ($options['operator'] == true && $value === null) { throw new MissingOptionsException(sprintf('The required option "type" is missing.')); } return $value; }); $resolver->setNormalizer('value_options', function (Options $options, $value) { return array_merge(array('required' => false), $value); }); }
public function configureOptions(OptionsResolver $resolver) { $manager = $this->manager; $resolver->setNormalizer('query_builder', function (Options $options, $value) use($manager) { return $manager->getRepository('EnhavoCategoryBundle:Category')->getByCollectionQuery($options['category_name']); }); $resolver->setDefaults(array('expanded' => true, 'multiple' => true, 'class' => $this->dataClass, 'category_name' => $this->categoryDefaultCollection, 'translation_domain' => 'EnhavoCategoryBundle')); $resolver->setNormalizer('label', function (Options $options, $value) { if ($options['multiple']) { return 'category.label.categories'; } return 'category.label.category'; }); }
private function setNormalizers() { $this->resolver->setNormalizer(TCO::TEMPLATES, function (Options $options, $value) { return $this->makeTemplatePathsAbsolute($value, $options); }); $this->resolver->setNormalizer(TCO::RESOURCES, function (Options $options, $resources) { $absolutizedResources = []; foreach ($resources as $key => $resource) { $key = $options['templatesPath'] . '/' . $key; $absolutizedResources[$key] = $resource; } return $absolutizedResources; }); }
/** * @param EventDispatcherInterface $dispatcher */ public function __construct(EventDispatcherInterface $dispatcher) { $this->dispatcher = $dispatcher; $this->specResolver = new OptionsResolver(); $this->specResolver->setDefaults(array('on' => self::ALL, 'from' => self::ALL, 'to' => self::ALL)); $this->specResolver->setAllowedTypes('on', array('string', 'array')); $this->specResolver->setAllowedTypes('from', array('string', 'array')); $this->specResolver->setAllowedTypes('to', array('string', 'array')); $toArrayNormalizer = function (Options $options, $value) { return (array) $value; }; $this->specResolver->setNormalizer('on', $toArrayNormalizer); $this->specResolver->setNormalizer('from', $toArrayNormalizer); $this->specResolver->setNormalizer('to', $toArrayNormalizer); }
/** * @inheritdoc */ public function configurePayload(OptionsResolver $resolver) { $resolver->setRequired(0); $resolver->setAllowedTypes(0, 'numeric'); $resolver->setNormalizer(0, function (Options $options, $value) { if (null === ($listing = $this->scheduler->findFeed($value))) { throw new InvalidArgumentException(sprintf('Feed with id "%d" does not exist', $value)); } return $listing; }); $resolver->setDefaults([1 => false]); $resolver->setNormalizer(1, function (Options $options, $value) { return (bool) $value; }); }
/** * {@inheritdoc} */ public function configureOptions(OptionsResolver $resolver) { $entryOptionsNormalizer = function (Options $options, $value) { $value['block_name'] = 'entry'; return $value; }; $optionsNormalizer = function (Options $options, $value) use($entryOptionsNormalizer) { if (null !== $value) { @trigger_error('The form option "options" is deprecated since version 2.8 and will be removed in 3.0. Use "entry_options" instead.', E_USER_DEPRECATED); } return $entryOptionsNormalizer($options, $value); }; $typeNormalizer = function (Options $options, $value) { if (null !== $value) { @trigger_error('The form option "type" is deprecated since version 2.8 and will be removed in 3.0. Use "entry_type" instead.', E_USER_DEPRECATED); } }; $entryType = function (Options $options) { if (null !== $options['type']) { return $options['type']; } return __NAMESPACE__ . '\\TextType'; }; $entryOptions = function (Options $options) { if (1 === count($options['options']) && isset($options['block_name'])) { return array(); } return $options['options']; }; $resolver->setDefaults(array('allow_add' => false, 'allow_delete' => false, 'prototype' => true, 'prototype_data' => null, 'prototype_name' => '__name__', 'type' => null, 'options' => null, 'entry_type' => $entryType, 'entry_options' => $entryOptions, 'delete_empty' => false)); $resolver->setNormalizer('options', $optionsNormalizer); $resolver->setNormalizer('entry_options', $entryOptionsNormalizer); }
/** * @param StateMachineInterface $stateMachine */ private function loadTransitions(StateMachineInterface $stateMachine) { $resolver = new OptionsResolver(); $resolver->setRequired(array('from', 'to')); $resolver->setDefaults(array('guard' => null)); $resolver->setNormalizer('from', function (Options $options, $v) { return (array) $v; }); $resolver->setNormalizer('guard', function (Options $options, $v) { return !isset($v) ? null : $v; }); foreach ($this->config['transitions'] as $transition => $config) { $config = $resolver->resolve($config); $stateMachine->addTransition(new Transition($transition, $config['from'], $config['to'], $config['guard'])); } }
public function configureOptions(OptionsResolver $resolver) { $resolver->setDefaults(array('label' => 'resource', 'attr' => $this->defaultAttributes, 'display_view_button' => true, 'display_browse_button' => true, 'display_download_button' => true)); $resolver->setNormalizer('attr', function (Options $options, $value) { return array_merge($this->defaultAttributes, $value); }); }
private function setNormalizers() { $this->resolver->setNormalizer(CO::ANNOTATION_GROUPS, function (Options $options, $value) { $value = (array) $value; if ($options[CO::DEPRECATED]) { $value[] = CO::DEPRECATED; } if ($options[CO::TODO]) { $value[] = CO::TODO; } return array_unique($value); }); $this->resolver->setNormalizer(CO::DESTINATION, function (Options $options, $value) { return $this->fileSystem->getAbsolutePath($value); }); $this->resolver->setNormalizer(CO::BASE_URL, function (Options $options, $value) { return rtrim($value, '/'); }); $this->resolver->setNormalizer(CO::SOURCE, function (Options $options, $value) { if (!is_array($value)) { $value = [$value]; } foreach ($value as $key => $source) { $value[$key] = $this->fileSystem->getAbsolutePath($source); } return $value; }); $this->resolver->setNormalizer(CO::SOURCE_CODE, function (Options $options) { return !$options[CO::NO_SOURCE_CODE]; }); $this->resolver->setNormalizer(CO::TEMPLATE_CONFIG, function (Options $options, $value) { return $this->fileSystem->getAbsolutePath($value); }); }
public function configureOptions(OptionsResolver $resolver) { // Les valeurs par défault $resolver->setDefaults(array("host" => "smtp.example.org", "username" => "user", "password" => 'pa$$word', "port" => "25", 'encryption' => null)); // Les options obligatoire $resolver->setRequired(array('host', 'username', 'password')); // Les type de valeur autorisé pour le port $resolver->setAllowedTypes("port", array("int")); // Les valeur autorisé pour l'username $resolver->setAllowedValues("username", array("john", "doe", "johndoe")); // On normalise le host en fornction de l'encryption ssl ou non $resolver->setNormalizer("host", function (Options $options, $value) { if (!in_array(substr($value, 0, 7), array("http://", "https://"))) { if ("ssl" === $options["encryption"]) { $value = "https://" . $value; } else { $value = "http://" . $value; } return $value; } }); // On change la valeur par défault du port en fonction de l'encryption ssl ou non $resolver->setDefault("port", function (Options $options) { if ("ssl" === $options["encryption"]) { return 465; } return 25; }); }
/** * {@inheritdoc} */ public function configureOptions(OptionsResolver $resolver) { // Make sure that validation groups end up as null, closure or array $validationGroupsNormalizer = function (Options $options, $groups) { if (false === $groups) { return array(); } if (empty($groups)) { return; } if (is_callable($groups)) { return $groups; } if ($groups instanceof GroupSequence) { return $groups; } return (array) $groups; }; $resolver->setDefaults(array( 'validation_groups' => null, )); $resolver->setNormalizer('validation_groups', $validationGroupsNormalizer); }
/** * {@inheritdoc} */ public function configureOptions(OptionsResolver $resolver) { $resolver->setDefaults(array('expanded' => true)); $resolver->setNormalizer('choices', function () { return array('attr1' => 'Attribute 1', 'attr2' => 'Attribute 2'); }); }
/** * Configures the options for this type. * * @param OptionsResolver $resolver The resolver for the options. */ public function configureOptions(OptionsResolver $resolver) { $resolver->setDefaults(array('border' => false, 'sortable' => false, 'sortable_property' => 'position', 'prototype' => true, 'allow_add' => true, 'by_reference' => false, 'allow_delete' => true)); $resolver->setNormalizer('prototype_name', function (Options $options, $value) { return '__' . $options['type'] . '__'; }); }
/** * {@inheritdoc} */ public function configureOptions(OptionsResolver $resolver) { $resolver->setDefaults(array('em' => null, 'property' => null, 'queryBuilder' => null, 'multiple' => true, 'values_delimiter' => ','))->setAllowedValues('multiple', [true, false])->setRequired(array('class')); $registry = $this->registry; $resolver->setNormalizer('em', function (Options $options, $em) use($registry) { if (null !== $em) { if ($em instanceof EntityManager) { return $em; } elseif (is_string($em)) { $em = $registry->getManager($em); } else { throw new FormException(sprintf('Option "em" should be a string or entity manager object, %s given', is_object($em) ? get_class($em) : gettype($em))); } } else { $em = $registry->getManagerForClass($options['class']); } if (null === $em) { throw new FormException(sprintf('Class "%s" is not a managed Doctrine entity. Did you forget to map it?', $options['class'])); } return $em; })->setNormalizer('queryBuilder', function (Options $options, $queryBuilder) { if (null !== $queryBuilder && !is_callable($queryBuilder)) { throw new FormException(sprintf('Option "queryBuilder" should be a callable, %s given', is_object($queryBuilder) ? get_class($queryBuilder) : gettype($queryBuilder))); } return $queryBuilder; }); }
/** * {@inheritdoc} */ public function configureOptions(OptionsResolver $resolver) { $resolver->setDefaults(['choice_label' => 'name', 'choices_as_values' => true]); $resolver->setNormalizer('choices', function () { // var_dump($this->repository->findAll()); die; return $this->repository->findAll(); }); }
/** * {@inheritdoc} */ public function configureOptions(OptionsResolver $resolver) { $translator = $this->translator; $translationDomain = $this->translationDomain; $resolver->setNormalizer('post_max_size_message', function (Options $options, $errorMessage) use($translator, $translationDomain) { return $translator->trans($errorMessage, array(), $translationDomain); }); }
/** * {@inheritdoc} */ protected function configureOptions(OptionsResolver $resolver) { $resolver->setRequired(['alias', 'source', 'aggregated']); $resolver->setDefaults(['aggregated' => false]); $resolver->setNormalizer('aggregated', function ($options) { return $this->isAggregateColumn($options['source']); }); }
/** * Resolve amount option * * @param OptionsResolver $resolver */ protected function setCustomerInfoResolver(OptionsResolver $resolver) { $resolver->setAllowedTypes('customer_info', Customer::class); /** @noinspection PhpUnusedParameterInspection */ $resolver->setNormalizer('customer_info', function (Options $options, Customer $value) { return $value->serialize(); }); }
/** * {@inheritdoc} */ public function configureOptions(OptionsResolver $resolver) { $defaultConfigs = ['placeholder' => 'oro.activity.contexts.placeholder', 'allowClear' => true, 'multiple' => true, 'separator' => ';', 'forceSelectedData' => true, 'minimumInputLength' => 0]; $resolver->setDefaults(['tooltip' => false, 'configs' => $defaultConfigs]); $resolver->setNormalizer('configs', function (Options $options, $configs) use($defaultConfigs) { return array_replace_recursive($defaultConfigs, $configs); }); }
/** * {@inheritdoc} */ public function configureOptions(OptionsResolver $resolver) { $optionsNormalizer = function (Options $options, $value) { $value['block_name'] = 'entry'; return $value; }; $resolver->setDefaults(array('allow_add' => false, 'allow_delete' => false, 'prototype' => true, 'prototype_name' => '__name__', 'type' => 'text', 'options' => array(), 'delete_empty' => false)); $resolver->setNormalizer('options', $optionsNormalizer); }
/** * {@inheritdoc} */ public function configureOptions(OptionsResolver $resolver) { $entryOptionsNormalizer = function (Options $options, $value) { $value['block_name'] = 'entry'; return $value; }; $resolver->setDefaults(array('allow_add' => false, 'allow_delete' => false, 'prototype' => true, 'prototype_data' => null, 'prototype_name' => '__name__', 'entry_type' => __NAMESPACE__ . '\\TextType', 'entry_options' => array(), 'delete_empty' => false)); $resolver->setNormalizer('entry_options', $entryOptionsNormalizer); }