/**
* {@inheritdoc}
*/
public function create($schemaAlias, $data = null, array $options = [])
{
$schema = $this->schemaRegistry->get($schemaAlias);
$builder = $this->formFactory->createBuilder('form', $data, array_merge_recursive(['data_class' => null], $options));
$schema->buildForm($builder);
return $builder->getForm();
}
/**
* {@inheritdoc}
*/
public function get($type)
{
if (!$this->decoratedRegistry->has($type)) {
return $this->defaultResolver;
}
return $this->decoratedRegistry->get($type);
}
/**
* {@inheritdoc}
*/
public function apply(DataSourceInterface $dataSource, Grid $grid, Parameters $parameters)
{
if ($parameters->has(ResourceOwnerFilter::TYPE)) {
$this->filtersRegistry->get(ResourceOwnerFilter::TYPE)->apply($dataSource, ResourceOwnerFilter::FIELD, $parameters->get(ResourceOwnerFilter::TYPE), []);
}
return $this->filtersApplicator->apply($dataSource, $grid, $parameters);
}
/**
* @param FormInterface $form
* @param string $ruleType
* @param array $data
*/
protected function addConfigurationFields(FormInterface $form, $ruleType, array $data = [])
{
/** @var RuleCheckerInterface $checker */
$checker = $this->checkerRegistry->get($ruleType);
$configurationField = $this->factory->createNamed('configuration', $checker->getConfigurationFormType(), $data, ['auto_initialize' => false]);
$form->add($configurationField);
}
/**
* {@inheritdoc}
*/
public function calculate(PriceableInterface $subject, array $context = array())
{
if (null === ($type = $subject->getPricingCalculator())) {
throw new \InvalidArgumentException('Cannot calculate the price for PriceableInterface instance without calculator defined.');
}
$calculator = $this->registry->get($type);
return $calculator->calculate($subject, $subject->getPricingConfiguration(), $context);
}
/**
* {@inheritdoc}
*/
public function getDataSource(Grid $grid, Parameters $parameters)
{
$driver = $grid->getDriver();
if (!$this->driversRegistry->has($driver)) {
throw new UnsupportedDriverException($driver);
}
return $this->driversRegistry->get($driver)->getDataSource($grid->getDriverConfiguration(), $parameters);
}
/**
* {@inheritdoc}
*
* @throws \InvalidArgumentException If the report subject does not have a renderer.
*/
public function render(ReportInterface $subject, Data $data)
{
if (null === ($type = $subject->getRenderer())) {
throw new \InvalidArgumentException('Cannot render data for ReportInterface instance without renderer defined.');
}
$renderer = $this->registry->get($type);
return $renderer->render($subject, $data);
}
/**
* {@inheritdoc}
*/
public function validate($value, Constraint $constraint)
{
if (!$value instanceof AttributeValueInterface) {
throw new UnexpectedTypeException(get_class($value), AttributeValueInterface::class);
}
$attributeType = $this->attributeTypeRegistry->get($value->getType());
$attributeType->validate($value, $this->context, $value->getAttribute()->getConfiguration());
}
/**
* @param Field $field
* @param $data
*/
public function renderField(GridView $gridView, Field $field, $data)
{
$fieldType = $this->fieldsRegistry->get($field->getType());
$resolver = new OptionsResolver();
$fieldType->configureOptions($resolver);
$options = $resolver->resolve($field->getOptions());
return $fieldType->render($field, $data, $options);
}
/**
* {@inheritdoc}
*/
public function calculate(ShippingSubjectInterface $subject)
{
if (null === ($method = $subject->getMethod())) {
throw new UndefinedShippingMethodException('Cannot calculate charge for shipping subject without defined shipping method.');
}
$calculator = $this->registry->get($method->getCalculator());
return $calculator->calculate($subject, $method->getConfiguration());
}
/**
* {@inheritdoc}
*/
public function configureOptions(OptionsResolver $resolver)
{
$resolver->setDefaults(['resource' => null, 'choices' => function (Options $options) {
return $options['function']($this->resourceRepositoryRegistry->get($options['resource']), $options);
}, 'function' => function (RepositoryInterface $repository, Options $options) {
return $repository->findAll();
}])->setRequired(['resource']);
}
/**
* {@inheritdoc}
*/
public function createTyped($type)
{
/** @var AttributeTypeInterface $attributeType */
$attributeType = $this->attributeTypesRegistry->get($type);
$attribute = $this->factory->createNew();
$attribute->setType($type);
$attribute->setStorageType($attributeType->getStorageType());
return $attribute;
}
/**
* {@inheritdoc}
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
if (!$options['multiple']) {
$builder->addModelTransformer(new ResourceToIdentifierTransformer($this->resourceRepositoryRegistry->get($options['resource']), $options['choice_value']));
}
if ($options['multiple']) {
$builder->addModelTransformer(new RecursiveTransformer(new ResourceToIdentifierTransformer($this->resourceRepositoryRegistry->get($options['resource']), $options['choice_value'])))->addViewTransformer(new CollectionToStringTransformer(','));
}
}
/**
* {@inheritdoc}
*/
public function calculate(PaymentSubjectInterface $payment)
{
if (null === $payment->getMethod()) {
throw new \InvalidArgumentException("Cannot calculate fee for payment without payment method configured.");
}
/** @var FeeCalculatorInterface $feeCalculator */
$feeCalculator = $this->serviceRegistry->get($payment->getMethod()->getFeeCalculator());
return $feeCalculator->calculate($payment, $payment->getMethod()->getFeeCalculatorConfiguration());
}
/**
* {@inheritdoc}
*
* @throws \InvalidArgumentException If the report does not have a data fetcher.
*/
public function fetch(ReportInterface $report, array $configuration = [])
{
if (null === ($type = $report->getDataFetcher())) {
throw new \InvalidArgumentException('Cannot fetch data for ReportInterface instance without DataFetcher defined.');
}
$dataFetcher = $this->registry->get($type);
$configuration = empty($configuration) ? $report->getDataFetcherConfiguration() : $configuration;
return $dataFetcher->fetch($configuration);
}
/**
* {@inheritdoc}
*/
public function calculate(ShippingSubjectInterface $subject)
{
// FIXME: ShippingSubjectInterface does not have any of called methods!
if (null === ($method = $subject->getMethod())) {
throw new UndefinedShippingMethodException('Cannot calculate charge for shipping subject without defined shipping method.');
}
/** @var CalculatorInterface $calculator */
$calculator = $this->registry->get($method->getCalculator());
return $calculator->calculate($subject, $method->getConfiguration());
}
/**
* {@inheritdoc}
*/
public function getDataSource(Grid $grid, Parameters $parameters)
{
$driverName = $grid->getDriver();
if (!$this->driversRegistry->has($driverName)) {
throw new UnsupportedDriverException($driverName);
}
/** @var DriverInterface $driver */
$driver = $this->driversRegistry->get($driverName);
return $driver->getDataSource($grid->getDriverConfiguration(), $parameters);
}
/**
* @param FormInterface $form
* @param string $calculatorName
* @param array $data
*/
protected function addConfigurationFields(FormInterface $form, $calculatorName, array $data = [])
{
/** @var CalculatorInterface $calculator */
$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);
}
/**
* Add configuration fields to the form.
*
* @param FormInterface $form
* @param string $dataFetcherType
* @param array $config
*/
protected function addConfigurationFields(FormInterface $form, $dataFetcherType, array $config = [])
{
$dataFetcher = $this->dataFecherRegistry->get($dataFetcherType);
$formType = $dataFetcher->getType();
try {
$configurationField = $this->factory->createNamed('dataFetcherConfiguration', $formType, $config, ['auto_initialize' => false]);
} catch (\InvalidArgumentException $e) {
return;
}
$form->add($configurationField);
}
/**
* Add configuration fields to the form
*
* @param FormInterface $form
* @param string $rendererType
* @param array $data
*/
public function addConfigurationFields(FormInterface $form, $rendererType, array $data = array())
{
$renderer = $this->rendererRegistry->get($rendererType);
$formType = sprintf('sylius_renderer_%s', $renderer->getType());
try {
$configurationField = $this->factory->createNamed('rendererConfiguration', $formType, $data, array('auto_initialize' => false));
} catch (\InvalidArgumentException $e) {
return;
}
$form->add($configurationField);
}
/**
* @param FormInterface $form
* @param string $feeCalculatorType
* @param array $data
*/
private function addConfigurationFields(FormInterface $form, $feeCalculatorType, $data = array())
{
$feeCalculator = $this->feeCalculatorRegistry->get($feeCalculatorType);
$formType = sprintf('sylius_fee_calculator_%s', $feeCalculator->getType());
try {
$configurationField = $this->factory->createNamed('feeCalculatorConfiguration', $formType, $data, array('auto_initialize' => false));
} catch (\InvalidArgumentException $exception) {
return;
}
$form->add($configurationField);
}
/**
* Add configuration fields to the form.
*
* @param FormInterface $form
* @param string $rendererType
* @param array $data
*/
public function addConfigurationFields(FormInterface $form, $rendererType, array $data = [])
{
/** @var RendererInterface $renderer */
$renderer = $this->rendererRegistry->get($rendererType);
$formType = $renderer->getType();
try {
$configurationField = $this->factory->createNamed('rendererConfiguration', $formType, $data, ['auto_initialize' => false]);
} catch (\InvalidArgumentException $e) {
return;
}
$form->add($configurationField);
}
/**
* {@inheritdoc}
*/
public function isEligible(ShippingSubjectInterface $subject, ShippingMethodInterface $method)
{
if (!$this->isCategoryEligible($subject, $method)) {
return false;
}
foreach ($method->getRules() as $rule) {
$checker = $this->registry->get($rule->getType());
if (!$checker->isEligible($subject, $rule->getConfiguration())) {
return false;
}
}
return true;
}
function it_does_not_check_more_rules_if_one_has_returned_false(RuleCheckerInterface $cartQuantityRuleChecker, RuleCheckerInterface $itemTotalRuleChecker, RuleInterface $cartQuantityRule, RuleInterface $itemTotalRule, PromotionInterface $promotion, PromotionSubjectInterface $subject, ServiceRegistryInterface $rulesRegistry)
{
$promotion->hasRules()->willReturn(true);
$promotion->getRules()->willReturn([$cartQuantityRule, $itemTotalRule]);
$cartQuantityRule->getType()->willReturn(RuleInterface::TYPE_CART_QUANTITY);
$cartQuantityRule->getConfiguration()->willReturn([]);
$itemTotalRule->getType()->willReturn(RuleInterface::TYPE_ITEM_TOTAL);
$itemTotalRule->getConfiguration()->willReturn([]);
$rulesRegistry->get(RuleInterface::TYPE_CART_QUANTITY)->willReturn($cartQuantityRuleChecker);
$rulesRegistry->get(RuleInterface::TYPE_ITEM_TOTAL)->willReturn($itemTotalRuleChecker);
$cartQuantityRuleChecker->isEligible($subject, [])->willReturn(false);
$itemTotalRuleChecker->isEligible($subject, [])->shouldNotBeCalled();
$this->isEligible($subject, $promotion)->shouldReturn(false);
}
function it_does_not_check_more_rules_if_one_has_returned_false(ServiceRegistryInterface $rulesRegistry, RuleCheckerInterface $firstRuleChecker, RuleCheckerInterface $secondRuleChecker, RuleInterface $firstRule, RuleInterface $secondRule, PromotionInterface $promotion, PromotionSubjectInterface $subject)
{
$promotion->hasRules()->willReturn(true);
$promotion->getRules()->willReturn([$firstRule, $secondRule]);
$firstRule->getType()->willReturn('first_rule');
$firstRule->getConfiguration()->willReturn([]);
$secondRule->getType()->willReturn('second_rule');
$secondRule->getConfiguration()->willReturn([]);
$rulesRegistry->get('first_rule')->willReturn($firstRuleChecker);
$rulesRegistry->get('second_rule')->willReturn($secondRuleChecker);
$firstRuleChecker->isEligible($subject, [])->willReturn(false);
$secondRuleChecker->isEligible($subject, [])->shouldNotBeCalled();
$this->isEligible($subject, $promotion)->shouldReturn(false);
}
/**
* {@inheritdoc}
*/
public function apply(DataSourceInterface $dataSource, Grid $grid, Parameters $parameters)
{
if (!$parameters->has('criteria')) {
return;
}
$criteria = $parameters->get('criteria');
foreach ($criteria as $name => $data) {
if (!$grid->hasFilter($name)) {
continue;
}
$filter = $grid->getFilter($name);
$this->filtersRegistry->get($filter->getType())->apply($dataSource, $name, $data, $filter->getOptions());
}
}
/**
* {@inheritdoc}
*/
public function buildView(FormView $view, FormInterface $form, array $options)
{
$paymentCosts = array();
$payment = $view->parent->vars['value']->getPayments()->last();
foreach ($view->vars['choices'] as $choiceView) {
$method = $choiceView->data;
if (!$method instanceof PaymentMethodInterface) {
throw new UnexpectedTypeException($method, 'Sylius\\Component\\Payment\\Model\\PaymentMethodInterface');
}
$feeCalculator = $this->feeCalculatorRegistry->get($method->getFeeCalculator());
$payment->setMethod($method);
$paymentCosts[$choiceView->value] = $feeCalculator->calculate($payment, $method->getFeeCalculatorConfiguration());
}
$view->vars['paymentCosts'] = $paymentCosts;
}
function it_renders_field_with_data_via_appriopriate_field_type(GridView $gridView, Field $field, ServiceRegistryInterface $fieldsRegistry, FieldTypeInterface $fieldType)
{
$field->getType()->willReturn('string');
$fieldsRegistry->get('string')->willReturn($fieldType);
$fieldType->render($field, 'Value')->willReturn('<strong>Value</strong>');
$this->renderField($gridView, $field, 'Value')->shouldReturn('<strong>Value</strong>');
}
function it_should_create_a_form_for_given_schema_namespace(FormInterface $form, FormBuilder $formBuilder, FormFactoryInterface $formFactory, SchemaInterface $schema, ServiceRegistryInterface $schemaRegistry)
{
$schemaRegistry->get('sylius_general')->willReturn($schema);
$formFactory->createBuilder('form', null, ['data_class' => null])->willReturn($formBuilder);
$schema->buildForm($formBuilder)->shouldBeCalled()->willReturn($formBuilder);
$formBuilder->getForm()->willReturn($form);
$this->create('sylius_general')->shouldReturn($form);
}
function it_uses_a_correct_driver_to_get_the_data_for_a_grid(ServiceRegistryInterface $driversRegistry, DriverInterface $driver, Grid $grid, Parameters $parameters)
{
$grid->getDriver()->willReturn('doctrine/orm');
$grid->getDriverConfiguration()->willReturn(['resource' => 'sylius.tax_category']);
$driversRegistry->has('doctrine/orm')->willReturn(true);
$driversRegistry->get('doctrine/orm')->willReturn($driver);
$driver->getDataSource(['resource' => 'sylius.tax_category'], $parameters)->willReturn(['foo', 'bar']);
$this->getDataSource($grid, $parameters)->shouldReturn(['foo', 'bar']);
}
