Sigmapix\Sonata\ImportBundle\Admin\ImportableAdminTrait

Complexity

Total Complexity

29

Size/Duplication

Total Lines	254
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	configureActionButtons()	0	8	1
	getClass()	0	1	?
	getConfigurationPool()	0	1	?
	getFormContractor()	0	1	?
A	getImportFormBuilder()	0	19	3
B	defineImportFormBuilder()	0	47	6
A	getImportForm()	0	6	1
B	configureImportSteps()	0	18	7
A	preImport()	0	3	1
A	postImport()	0	3	1
	configureImportFields()	0	1	?
	attachInlineValidator()	0	1	?
A	configureRoutes()	0	8	1
A	buildImportForm()	0	7	2
B	nearest()	0	25	6

<?php

namespace Sigmapix\Sonata\ImportBundle\Admin;

use Port\Steps\Step\ValueConverterStep;
use Port\Steps\StepAggregator;
use Port\ValueConverter\DateTimeValueConverter;
use Sigmapix\Sonata\ImportBundle\Form\Type\ImportFieldChoiceType;
use Sonata\AdminBundle\Admin\AbstractAdmin;
use Sonata\AdminBundle\Admin\Pool;
use Sonata\AdminBundle\Builder\FormContractorInterface;
use Sonata\AdminBundle\Form\FormMapper;
use Sonata\AdminBundle\Route\RouteCollection;
use Sonata\DoctrineORMAdminBundle\Admin\FieldDescription;
use Symfony\Bridge\Doctrine\Form\Type\EntityType;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\Form;
use Symfony\Component\Form\FormBuilder;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Translation\TranslatorInterface;

/**
 * Trait ImportableAdminTrait.
 */
trait ImportableAdminTrait
{
    /**
     * Options to set to the form (ie, validation_groups).
     *
     * @var array
     */
    protected $formOptions = [];
    /**
     * @var Form
     */
    private $importForm;

    /**
     * {@inheritdoc}
     */
    abstract public function getClass();

    /**
     * @return Pool
     */
    abstract public function getConfigurationPool();

    /**
     * @return FormContractorInterface
     */
    abstract public function getFormContractor();

    /**
     * {@inheritdoc}
     *
     * @throws \ReflectionException
     */
    public function getImportFormBuilder(array $headers)
    {
        $class = $this->hasActiveSubClass() ? $this->getActiveSubClass() : $this->getClass();

It seems like hasActiveSubClass() must be provided by classes using this trait. How about adding it as abstract method to this trait?

It seems like getActiveSubClass() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        if ((new \ReflectionClass($class))->isAbstract()) {
            // If $class is Abstract, then use the first one.
            // Developers should then instantiate the good class by overriding DoctrineWrite::writeItem()
            $class = array_values($this->getSubClasses())[0];

It seems like getSubClasses() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        $this->formOptions['data_class'] = $class;

        $formBuilder = $this->getFormContractor()->getFormBuilder(
            'import_form', $this->formOptions
        );

        $this->defineImportFormBuilder($formBuilder, $headers);

        return $formBuilder;
    }

    /**
     * @param FormBuilderInterface $formBuilder
     * @param array                $headers
     *                                          todo: use defineFormBuilder for import Action and upload Action
     */
    public function defineImportFormBuilder(FormBuilderInterface $formBuilder, array $headers)
    {
        /** @var AbstractAdmin $this */
        $mapper = new FormMapper($this->getFormContractor(), $formBuilder, $this);
        $this->configureImportFields($mapper);

The method configureImportFields() does not exist on Sonata\AdminBundle\Admin\AbstractAdmin. Did you maybe mean configure()?

        /** @var ContainerInterface $container */
        $container = $this->getConfigurationPool()->getContainer();
        $trans = $container->get('translator');

        $oldValue = ini_get('mbstring.substitute_character');
        ini_set('mbstring.substitute_character', 'none');
        foreach ($formBuilder as $field) {
            /* @var FormBuilder $field */
            if ($field->getType()->getInnerType() instanceof EntityType) {
                continue;
            }
            $propertyPath = $field->getPropertyPath();
            if ($propertyPath && $propertyPath->getLength() > 1) {
                $mapper->add(
                    (string) $propertyPath, ImportFieldChoiceType::class, [
                    'choices' => $headers,
                    'data' => $this->nearest($field->getOption('label'), $headers, $trans),

The method nearest() does not seem to exist on object<Sonata\AdminBundle\Admin\AbstractAdmin>.

                    'mapped' => false,
                    'label' => $field->getOption('label'),
                ]);
            } elseif ('id' === (string) $propertyPath) {
                $mapper->add($field->getName(), ImportFieldChoiceType::class, [
                    'choices' => $headers,
                    'data' => $this->nearest($field->getOption('label'), $headers, $trans),

The method nearest() does not seem to exist on object<Sonata\AdminBundle\Admin\AbstractAdmin>.

                    'mapped' => false,
                    'label' => $field->getOption('label'),
                ]);
            } else {
                $mapper->add($field->getName(), ImportFieldChoiceType::class, [
                    'choices' => $headers,
                    'data' => $this->nearest($field->getOption('label'), $headers, $trans, $field->getOption('translation_domain')),

The method nearest() does not seem to exist on object<Sonata\AdminBundle\Admin\AbstractAdmin>.

                    'mapped' => $field->getOption('mapped'),
                    'label' => $field->getOption('label'),
                    'label_format' => $field->getOption('label_format'), // This will be used for DateTimeConverter
                    'translation_domain' => $field->getOption('translation_domain'),
                ]);
            }
        }
        ini_set('mbstring.substitute_character', $oldValue);
        $formBuilder->add('import', SubmitType::class);
        $this->attachInlineValidator();

The method attachInlineValidator() cannot be called from this context as it is declared protected in class Sonata\AdminBundle\Admin\AbstractAdmin.

    }

    /**
     * @param $admin
     * @param null $object
     *
     * @return mixed
     */
    public function configureActionButtons($admin, $object = null)
    {
        $buttonList = parent::configureActionButtons($admin, $object);
        $buttonList['import'] = [
            'template' => 'SigmapixSonataImportBundle:Button:import_button.html.twig',
        ];
        return $buttonList;
    }

    /**
     * @param array $headers
     *
     * @throws \ReflectionException
     *
     * @return Form
     */
    public function getImportForm(array $headers)
    {
        $this->buildImportForm($headers);

        return $this->importForm;
    }

    /**
     * @param StepAggregator $workflow
     */
    public function configureImportSteps(StepAggregator $workflow)
    {
        $dateTimeFields = [];
        foreach ($this->importForm as $f) {
            /** @var Form $f */
            /** @var FieldDescription $fieldOptions */
            $fieldOptions = $f->getConfig()->getOption('sonata_field_description');
            if ($fieldOptions && ('datetime' === $fieldOptions->getMappingType() || 'date' === $fieldOptions->getMappingType() || $f->getConfig()->getOption('label_format'))) {
                $dateTimeFields[$f->getName()] = $f->getConfig()->getOption('label_format');
            }
        }
        $converterStep = new ValueConverterStep();
        foreach ($dateTimeFields as $dateTimeField => $dateTimeFormat) {
            $converter = new DateTimeValueConverter($dateTimeFormat);
            $converterStep->add('['.$dateTimeField.']', $converter);
        }
        $workflow->addStep($converterStep);
    }

    /**
     * This method can be overloaded in your Admin service.
     * It's called from importAction.
     *
     * @param Request $request
     * @param Form    $form
     *
     * @return Response|null
     */
    public function preImport(Request $request, Form $form)

The parameter $request is not used and could be removed.

The parameter $form is not used and could be removed.

    {
    }

    /**
     * This method can be overloaded in your Admin service.
     * It's called from importAction.
     *
     * @param Request      $request
     * @param UploadedFile $file
     * @param Form         $form
     * @param mixed        $results
     *
     * @return Response|null
     */
    public function postImport(Request $request, UploadedFile $file, Form $form, $results)

The parameter $request is not used and could be removed.

The parameter $file is not used and could be removed.

The parameter $form is not used and could be removed.

The parameter $results is not used and could be removed.

    {
    }

    /**
     * @param FormMapper $formMapper
     */
    abstract protected function configureImportFields(FormMapper $formMapper);

    /**
     * Attach the inline validator to the model metadata, this must be done once per admin.
     */
    abstract protected function attachInlineValidator();

    /**
     * @param RouteCollection $collection
     */
    protected function configureRoutes(RouteCollection $collection)
    {
        /* @var AbstractAdmin $this */
        $collection
                ->add('import', 'upload/{fileName}')
                ->add('upload')
        ;
    }

    /**
     * @param array $headers
     *
     * @throws \ReflectionException
     */
    protected function buildImportForm(array $headers)
    {
        if ($this->importForm) {
            return;
        }
        $this->importForm = $this->getImportFormBuilder($headers)->getForm();
    }

    /**
     * @param $input
     * @param $words
     * @param TranslatorInterface $trans
     * @param string              $domain
     *
     * @return string
     */
    private function nearest($input, $words, TranslatorInterface $trans, $domain = null)

This method is not used, and could be removed.

    {
        // TODO $input should be the $field, to try both 'name' and 'propertyPath' attributes
        $domain = $domain ?: 'messages';
        $closest = '';
        $shortest = -1;

        foreach ($words as $word) {
            $wordASCII = mb_convert_encoding($word, 'ASCII');
            $lev = levenshtein($input, $wordASCII);
            $levCase = levenshtein(strtolower($input), strtolower($wordASCII));
            $levTrans = levenshtein($trans->trans($input, [], $domain), $wordASCII);
            $lev = min([$lev, $levCase, $levTrans]);
            if (0 === $lev) {
                $closest = $word;
                break;
            }
            if ($lev <= $shortest || $shortest < 0) {
                $closest = $word;
                $shortest = $lev;
            }
        }

        return $closest;
    }
}