Obblm\Core\Form\Team\CompositionInducementsForm

Complexity

Total Complexity

15

Size/Duplication

Total Lines	93
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	mapFormsToData()	0	20	4
A	mapDataToForms()	0	13	5
A	configureOptions()	0	11	1
A	buildForm()	0	39	5

<?php

namespace Obblm\Core\Form\Team;

use Obblm\Core\Contracts\InducementInterface;
use Obblm\Core\Contracts\RuleHelperInterface;
use Obblm\Core\Entity\Team;
use Obblm\Core\Helper\TeamHelper;
use Obblm\Core\Validator\Constraints\Team\InducementsAmount;
use Obblm\Core\Validator\Constraints\Team\InducementsQuantity;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\DataMapperInterface;
use Symfony\Component\Form\Exception\UnexpectedTypeException;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class CompositionInducementsForm extends AbstractType implements DataMapperInterface
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        /** @var RuleHelperInterface $helper */
        $helper = $options['helper'];

        if ($builder->getData()) {
            /** @var Team $team */
            $team = $builder->getData();
            $budget = TeamHelper::getLastVersion($team)->getTreasure();
            if ($team->getCreationOption('inducement_allowed')) {
                if ($team->getCreationOption('inducements')) {
                    foreach ($team->getCreationOption('inducements') as $key) {
                        $inducement = $helper->getInducement($key);
                        $budget += $inducement->getValue();
                    }
                }
                $builder->add('inducements', InducementCollection::class, [
                    'allow_add' => true,
                    'allow_delete' => true,
                    'prototype' => true,
                    'error_bubbling' => false,
                    'entry_type' => InducementType::class,
                    'help' => 'obblm.forms.team.fields.inducement_help',
                    'help_translation_parameters' => ['%limit%' => $budget],
                    'constraints' => [
                        new InducementsAmount($budget, $budget),
                        new InducementsQuantity($helper)
                    ],
                    'entry_options' => [
                        'label' => 'inducement',
                        'choice_value' => 'key',
                        'group_by' => 'type',
                        'choices' => $helper->getInducementsFor($team, $budget, ['inducements']),
                        'choice_translation_domain' => $helper->getAttachedRule()->getRuleKey()
                    ]
                ]);
            }

            $builder->setDataMapper($this);
        }
    }

    public function mapDataToForms($viewData, iterable $forms)
    {
        if ($viewData === null) {
            return;
        }
        if (!$viewData instanceof Team) {
            throw new UnexpectedTypeException($viewData, Team::class);
        }

        /** @var FormInterface[] $forms */
        $forms = iterator_to_array($forms);

$forms of type Symfony\Component\Form\FormInterface[] is incompatible with the type Traversable expected by parameter $iterator of iterator_to_array().

        if (isset($forms['inducements']) && $viewData->getCreationOption('inducements')) {
            $forms['inducements']->setData($viewData->getCreationOption('inducements'));
        }
    }

    public function mapFormsToData(iterable $forms, &$viewData)
    {
        if ($viewData === null) {
            return;
        }
        if (!$viewData instanceof Team) {
            throw new UnexpectedTypeException($viewData, Team::class);
        }

        /** @var FormInterface[] $forms */
        $forms = iterator_to_array($forms);

$forms of type Symfony\Component\Form\FormInterface[] is incompatible with the type Traversable expected by parameter $iterator of iterator_to_array().

        $creationOptions = $viewData->getCreationOptions();
        if (isset($forms['inducements'])) {
            $inducements = array_map(function (InducementInterface $inducement) {
                return $inducement->getKey();
            }, $forms['inducements']->getData());
            $creationOptions['inducements'] = $inducements;
        }
        $viewData->setCreationOptions($creationOptions);

It seems like $creationOptions can also be of type null; however, parameter $creationOptions of Obblm\Core\Entity\Team::setCreationOptions() does only seem to accept array, maybe add an additional type check?

    }

    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'translation_domain' => 'obblm',
            'data_class' => Team::class,
            'helper' => null,
            'constraints' => [
            ]
        ]);

        $resolver->setAllowedTypes('helper', [RuleHelperInterface::class]);
    }
}