StructuralEntityType::modelReverseTransform() - Code Metrics - Inspection of "Allow to create nested entitiy structures directly..." - Part-DB/Part-DB-symfony - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( f08540...e0c380 )

by Jan
created 2023-01-29 23:37 UTC
StructuralEntityType::modelReverseTransform() A

↳ Parent: StructuralEntityType
Complexity

Conditions	3
Paths	3
Size

Total Lines	21
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	3
eloc	5
nc	3
nop	2
dl	0
loc	21
rs	10
c	0
b	0
f	0
<?php
/**
 * This file is part of Part-DB (https://github.com/Part-DB/Part-DB-symfony).
 *
 * Copyright (C) 2019 - 2022 Jan Böhmer (https://github.com/jbtronics)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

declare(strict_types=1);

namespace App\Form\Type;

use App\Entity\Attachments\AttachmentType;
use App\Entity\Base\AbstractStructuralDBElement;
use App\Form\Type\Helper\StructuralEntityChoiceLoader;
use App\Services\Attachments\AttachmentURLGenerator;
use App\Services\Trees\NodesListBuilder;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\CallbackTransformer;
use Symfony\Component\Form\ChoiceList\Loader\CallbackChoiceLoader;
use Symfony\Component\Form\Event\PostSubmitEvent;
use Symfony\Component\Form\Event\PreSubmitEvent;
use Symfony\Component\Form\Exception\TransformationFailedException;
use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Form\FormEvents;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\Form\FormView;
use Symfony\Component\OptionsResolver\Options;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Validator\Constraints\AtLeastOneOf;
use Symfony\Component\Validator\Constraints\IsNull;
use Symfony\Component\Validator\Constraints\Valid;

/**
 * This class provides a choice form type similar to EntityType, with the difference, that the tree structure
 * of the StructuralDBElementRepository will be shown to user.
 */
class StructuralEntityType extends AbstractType
{
    protected EntityManagerInterface $em;
    protected AttachmentURLGenerator $attachmentURLGenerator;

    /**
     * @var NodesListBuilder
     */
    protected $builder;

    public function __construct(EntityManagerInterface $em, NodesListBuilder $builder, AttachmentURLGenerator $attachmentURLGenerator)
    {
        $this->em = $em;
        $this->builder = $builder;
        $this->attachmentURLGenerator = $attachmentURLGenerator;
    }

    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        $builder->addEventListener(FormEvents::PRE_SUBMIT, function (PreSubmitEvent $event) {
            //When the data contains non-digit characters, we assume that the user entered a new element.
            //In that case we add the new element to our choice_loader

            $data = $event->getData();
            if (null === $data || !is_string($data) || $data === "" || ctype_digit($data)) {
                return;
            }

            $form = $event->getForm();
            $options = $form->getConfig()->getOptions();
            $choice_loader = $options['choice_loader'];
            if ($choice_loader instanceof StructuralEntityChoiceLoader) {
                $choice_loader->setAdditionalElement($data);
            }
        });

       /* $builder->addEventListener(FormEvents::POST_SUBMIT, function (PostSubmitEvent $event) {
           $name =  $event->getForm()->getConfig()->getName();
           $data = $event->getForm()->getData();

           if ($event->getForm()->getParent() === null) {
               return;
           }

           $event->getForm()->getParent()->add($name, static::class, $event->getForm()->getConfig()->getOptions());
           $new_form = $event->getForm()->getParent()->get($name);
           $new_form->setData($data);
        });*/



        $builder->addModelTransformer(new CallbackTransformer(
            function ($value) use ($options) {
                return $this->modelTransform($value, $options);
            }, function ($value) use ($options) {
            return $this->modelReverseTransform($value, $options);
        }));
    }

    public function configureOptions(OptionsResolver $resolver): void
    {
        $resolver->setRequired(['class']);
        $resolver->setDefaults([
            'allow_add' => false,
            'show_fullpath_in_subtext' => true, //When this is enabled, the full path will be shown in subtext
            'subentities_of' => null,   //Only show entities with the given parent class
            'disable_not_selectable' => false,  //Disable entries with not selectable property
            'choice_value' => function (?AbstractStructuralDBElement $element) {
                if ($element === null) {
                    return null;
                }

                if ($element->getID() === null) {
                    //Must be the same as the separator in the choice_loader, otherwise this will not work!
                    return $element->getFullPath('->');
                }

                return $element->getID();
            }, //Use the element id as option value and for comparing items
            'choice_loader' => function (Options $options) {
                return new StructuralEntityChoiceLoader($options, $this->builder, $this->em);
            },
            'choice_label' => function (Options $options) {
                return function ($choice, $key, $value) use ($options) {
                    return $this->generateChoiceLabels($choice, $key, $value, $options);
                };
            },
            'choice_attr' => function (Options $options) {
                return function ($choice, $key, $value) use ($options) {
                    return $this->generateChoiceAttr($choice, $key, $value, $options);
                };
            },
            'group_by' => function (AbstractStructuralDBElement $element)
            {
                //Show entities that are not added to DB yet separately from other entities
                if ($element->getID() === null) {
                    return 'New (not added to DB yet)';
                }

                return null;
            },
            'choice_translation_domain' => false, //Don't translate the entity names
        ]);

        //Set the constraints for the case that allow add is enabled (we then have to check that the new element is valid)
        $resolver->setNormalizer('constraints', function (Options $options, $value) {
            if ($options['allow_add']) {
                $value[] = new Valid();
            }

            return $value;
        });

        $resolver->setDefault('empty_message', null);

        $resolver->setDefault('controller', 'elements--structural-entity-select');

        $resolver->setDefault('attr', static function (Options $options) {
            $tmp = [
                'data-controller' => $options['controller'],
                'data-allow-add' => $options['allow_add'] ? 'true' : 'false',
            ];
            if ($options['empty_message']) {
                $tmp['data-empty-message'] = $options['empty_message'];
            }

            return $tmp;
        });
    }


    public function getParent(): string
    {
        return ChoiceType::class;
    }

    public function modelTransform($value, array $options)
    public function modelTransform($value, /** @scrutinizer ignore-unused */ array $options)
    {
        return $value;
    }

    public function modelReverseTransform($value, array $options)
    {
        /* This step is important in combination with the caching!
           The elements deserialized from cache, are not known to Doctrinte ORM any more, so doctrine thinks,
           that the entity has changed (and so throws an exception about non-persited entities).
           This function just retrieves a fresh copy of the entity from database, so doctrine detect correctly that no
           change happened.
           The performance impact of this should be very small in comparison of the boost, caused by the caching.
        */

        if (null === $value) {
            return null;
        }

        //If the value is already in the db, retrieve it freshly
        if ($value->getID()) {
            return $this->em->find($options['class'], $value->getID());
        }

        //Otherwise just return the value
        return $value;
    }

    protected function generateChoiceAttr(AbstractStructuralDBElement $choice, $key, $value, $options): array
    {
        $tmp = [];

        //Disable attribute if the choice is marked as not selectable
        if ($options['disable_not_selectable'] && $choice->isNotSelectable()) {
            $tmp += ['disabled' => 'disabled'];
        }

        if ($choice instanceof AttachmentType) {
            $tmp += ['data-filetype_filter' => $choice->getFiletypeFilter()];
        }

        $level = $choice->getLevel();
        /** @var AbstractStructuralDBElement|null $parent */
        $parent = $options['subentities_of'];
        if (null !== $parent) {
            $level -= $parent->getLevel() - 1;
        }

        $tmp += [
            'data-level' => $level,
            'data-parent' => $choice->getParent() ? $choice->getParent()->getFullPath() : null,
            'data-image' => $choice->getMasterPictureAttachment() ? $this->attachmentURLGenerator->getThumbnailURL($choice->getMasterPictureAttachment(), 'thumbnail_xs') : null,
        ];

        if ($choice instanceof AttachmentType && !empty($choice->getFiletypeFilter())) {
            $tmp += ['data-filetype_filter' => $choice->getFiletypeFilter()];
        }

        return $tmp;
    }

    protected function getElementNameWithLevelWhitespace(AbstractStructuralDBElement $choice, $options, $whitespace = "&nbsp;&nbsp;&nbsp;"): string
    {
        /** @var AbstractStructuralDBElement|null $parent */
        $parent = $options['subentities_of'];

        /*** @var AbstractStructuralDBElement $choice */
        $level = $choice->getLevel();
        //If our base entity is not the root level, we need to change the level, to get zero position
        if (null !== $options['subentities_of']) {
            $level -= $parent->getLevel() - 1;
            $level -= $parent->/** @scrutinizer ignore-call */ getLevel() - 1;
        }

        $tmp = str_repeat($whitespace, $level); //Use 3 spaces for intendation
        $tmp .= htmlspecialchars($choice->getName());

        return $tmp;
    }

    protected function generateChoiceLabels(AbstractStructuralDBElement $choice, $key, $value, $options): string
    protected function generateChoiceLabels(AbstractStructuralDBElement $choice, $key, $value, /** @scrutinizer ignore-unused */ $options): string
    {
        return $choice->getName();
    }
}

Part-DB / Part-DB-symfony

Push — master ( f08540...e0c380 )

StructuralEntityType::modelReverseTransform() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
