chill-bundles/src/Bundle/ChillPersonBundle/Service/DocGenerator/AccompanyingPeriodContext.php

<?php

/**
 * Chill is a software for social workers
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Chill\PersonBundle\Service\DocGenerator;

use Chill\DocGeneratorBundle\Context\DocGeneratorContextInterface;
use Chill\DocGeneratorBundle\Context\DocGeneratorContextWithAdminFormInterface;
use Chill\DocGeneratorBundle\Context\DocGeneratorContextWithPublicFormInterface;
use Chill\DocGeneratorBundle\Context\Exception\UnexpectedTypeException;
use Chill\DocGeneratorBundle\Entity\DocGeneratorTemplate;
use Chill\DocStoreBundle\Entity\AccompanyingCourseDocument;
use Chill\DocStoreBundle\Entity\StoredObject;
use Chill\DocStoreBundle\Repository\DocumentCategoryRepository;
use Chill\MainBundle\Templating\TranslatableStringHelperInterface;
use Chill\PersonBundle\Entity\AccompanyingPeriod;
use Chill\PersonBundle\Entity\AccompanyingPeriodParticipation;
use Chill\PersonBundle\Entity\Person;
use Chill\PersonBundle\Templating\Entity\PersonRender;
use DateTime;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use Symfony\Bridge\Doctrine\Form\Type\EntityType;
use Symfony\Component\Form\Extension\Core\Type\CheckboxType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
use function array_key_exists;

class AccompanyingPeriodContext implements
    DocGeneratorContextInterface,
    DocGeneratorContextWithAdminFormInterface,
    DocGeneratorContextWithPublicFormInterface
{
    private DocumentCategoryRepository $documentCategoryRepository;

    private EntityManagerInterface $em;

    private NormalizerInterface $normalizer;

    private PersonRender $personRender;

    private TranslatableStringHelperInterface $translatableStringHelper;

    public function __construct(
        DocumentCategoryRepository $documentCategoryRepository,
        NormalizerInterface $normalizer,
        TranslatableStringHelperInterface $translatableStringHelper,
        EntityManagerInterface $em,
        PersonRender $personRender
    ) {
        $this->documentCategoryRepository = $documentCategoryRepository;
        $this->normalizer = $normalizer;
        $this->translatableStringHelper = $translatableStringHelper;
        $this->em = $em;
        $this->personRender = $personRender;
    }

    public function adminFormReverseTransform(array $data): array
    {
        return [
            'mainPerson' => $data['mainPerson'],
            'person1' => $data['person1'],
            'person2' => $data['person2'],
            'category' => [
                'idInsideBundle' => $data['category']->getIdInsideBundle(),
                'bundleId' => $data['category']->getBundleId(),
            ],
        ];
    }

    public function adminFormTransform(array $data): array
    {
        return [
            'mainPerson' => $data['mainPerson'] ?? false,
            'person1' => $data['person1'] ?? false,
            'person2' => $data['person2'] ?? false,
            'category' => array_key_exists('category', $data) ?
                    $this->documentCategoryRepository->find($data['category']) : null,
        ];
    }

    public function buildAdminForm(FormBuilderInterface $builder): void
    {
        $builder
            ->add('mainPerson', CheckboxType::class, [
                'required' => false,
            ])
            ->add('person1', CheckboxType::class, [
                'required' => false,
            ])
            ->add('person2', CheckboxType::class, [
                'required' => false,
            ])
            ->add('category', EntityType::class, [
                'placeholder' => 'Choose a document category',
                'class' => 'ChillDocStoreBundle:DocumentCategory',
                'query_builder' => static function (EntityRepository $er) {
                    return $er->createQueryBuilder('c')
                        ->where('c.documentClass = :docClass')
                        ->setParameter('docClass', AccompanyingCourseDocument::class);
                },
                'choice_label' => function ($entity = null) {
                    return $entity ? $this->translatableStringHelper->localize($entity->getName()) : '';
                },
            ]);
    }

    /**
     * @param AccompanyingPeriod $entity
     */
    public function buildPublicForm(FormBuilderInterface $builder, DocGeneratorTemplate $template, $entity): void
    {
        $options = $template->getOptions();
        $persons = $entity->getCurrentParticipations()->map(static function (AccompanyingPeriodParticipation $p) { return $p->getPerson(); })
            ->toArray();

        foreach (['mainPerson', 'person1', 'person2'] as $key) {
            if ($options[$key] ?? false) {
                $builder->add($key, EntityType::class, [
                    'class' => Person::class,
                    'choices' => $persons,
                    'choice_label' => function (Person $p) { return $this->personRender->renderString($p, []); },
                    'multiple' => false,
                    'expanded' => true,
                ]);
            }
        }
    }

    public function getData(DocGeneratorTemplate $template, $entity, array $contextGenerationData = []): array
    {
        if (!$entity instanceof AccompanyingPeriod) {
            throw new UnexpectedTypeException($entity, AccompanyingPeriod::class);
        }
        $options = $template->getOptions();

        $data = [];
        $data['course'] = $this->normalizer->normalize($entity, 'docgen', ['docgen:expects' => AccompanyingPeriod::class]);

        foreach (['mainPerson', 'person1', 'person2'] as $k) {
            if ($options[$k]) {
                $data[$k] = $this->normalizer->normalize($contextGenerationData[$k], 'docgen', ['docgen:expects' => Person::class]);
            }
        }

        return $data;
    }

    public function getDescription(): string
    {
        return 'A basic context for accompanying period';
    }

    public function getEntityClass(): string
    {
        return AccompanyingPeriod::class;
    }

    public static function getKey(): string
    {
        return self::class;
    }

    public function getName(): string
    {
        return 'Accompanying Period basic';
    }

    public function hasAdminForm(): bool
    {
        return true;
    }

    public function hasPublicForm(DocGeneratorTemplate $template, $entity): bool
    {
        $options = $template->getOptions();

        return $options['mainPerson'] || $options['person1'] || $options['person2'];
    }

    /**
     * @param AccompanyingPeriod $entity
     */
    public function storeGenerated(DocGeneratorTemplate $template, StoredObject $storedObject, object $entity, array $contextGenerationData): void
    {
        $doc = new AccompanyingCourseDocument();
        $doc->setTitle($this->translatableStringHelper->localize($template->getName()))
            ->setDate(new DateTime())
            ->setDescription($this->translatableStringHelper->localize($template->getName()))
            ->setCourse($entity)
            ->setObject($storedObject);

        if (array_key_exists('category', $template->getOptions()['category'])) {
            $doc
                ->setCategory(
                    $this->documentCategoryRepository->find(
                        $template->getOptions()['category']
                    )
                );
        }

        $this->em->persist($doc);
    }
}