Feature: [docgen] create a service to generate a document from a template

2025-08-21 07:03:49 +00:00 · 2023-02-14 19:35:28 +01:00
parent eac3471cbb
commit bb05ba0f17
8 changed files with 415 additions and 17 deletions
--- a/src/Bundle/ChillDocGeneratorBundle/GeneratorDriver/RelatorioDriver.php
+++ b/src/Bundle/ChillDocGeneratorBundle/GeneratorDriver/RelatorioDriver.php
@@ -53,6 +53,7 @@ final class RelatorioDriver implements DriverInterface
            $response = $this->client->request('POST', $this->url, [
                'headers' => $form->getPreparedHeaders()->toArray(),
                'body' => $form->bodyToIterable(),
+                'timeout' => '300',
            ]);

            return $response->getContent();
--- a/src/Bundle/ChillDocGeneratorBundle/Service/Generator/Generator.php
+++ b/src/Bundle/ChillDocGeneratorBundle/Service/Generator/Generator.php
@@ -0,0 +1,132 @@
+<?php
+
+namespace Chill\DocGeneratorBundle\Service\Generator;
+
+use Chill\DocGeneratorBundle\Context\ContextManagerInterface;
+use Chill\DocGeneratorBundle\Entity\DocGeneratorTemplate;
+use Chill\DocGeneratorBundle\GeneratorDriver\DriverInterface;
+use Chill\DocGeneratorBundle\GeneratorDriver\Exception\TemplateException;
+use Chill\DocStoreBundle\Entity\StoredObject;
+use Chill\DocStoreBundle\Service\StoredObjectManagerInterface;
+use Doctrine\ORM\EntityManagerInterface;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\HttpFoundation\File\File;
+
+class Generator
+{
+    private ContextManagerInterface $contextManager;
+
+    private DriverInterface $driver;
+
+    private EntityManagerInterface $entityManager;
+
+    private LoggerInterface $logger;
+
+    private StoredObjectManagerInterface $storedObjectManager;
+
+    public function __construct(
+        ContextManagerInterface $contextManager,
+        DriverInterface $driver,
+        EntityManagerInterface $entityManager,
+        LoggerInterface $logger,
+        StoredObjectManagerInterface $storedObjectManager
+    ) {
+        $this->contextManager = $contextManager;
+        $this->driver = $driver;
+        $this->entityManager = $entityManager;
+        $this->logger = $logger;
+        $this->storedObjectManager = $storedObjectManager;
+    }
+
+    /**
+     * @template T of File|null
+     * @template B of bool
+     * @param B $isTest
+     * @param (B is true ? T : null) $testFile
+     * @psalm-return (B is true ? string : null)
+     * @throws \Symfony\Component\Serializer\Exception\ExceptionInterface|\Throwable
+     */
+    public function generateDocFromTemplate(
+        DocGeneratorTemplate $template,
+        string               $entityClassName,
+        int                  $entityId,
+        ?StoredObject        $destinationStoredObject = null,
+        bool                 $isTest = false,
+        ?File                $testFile = null
+    ): ?string {
+        if ($destinationStoredObject instanceof StoredObject && StoredObject::STATUS_PENDING !== $destinationStoredObject->getStatus()) {
+            throw new ObjectReadyException();
+        }
+
+        $context = $this->contextManager->getContextByDocGeneratorTemplate($template);
+        $contextGenerationData = ['test_file' => $testFile];
+
+        $entity = $this
+            ->entityManager
+            ->find($context->getEntityClass(), $entityId)
+            ;
+
+        if (null === $entity) {
+            throw new RelatedEntityNotFoundException($entityClassName, $entityId);
+        }
+
+        if ($isTest && ($testFile instanceof File)) {
+            $dataDecrypted = file_get_contents($testFile->getPathname());
+        } else {
+            $dataDecrypted = $this->storedObjectManager->read($template->getFile());
+        }
+
+        try {
+            $generatedResource = $this
+                ->driver
+                ->generateFromString(
+                    $dataDecrypted,
+                    $template->getFile()->getType(),
+                    $context->getData($template, $entity, $contextGenerationData),
+                    $template->getFile()->getFilename()
+                );
+        } catch (TemplateException $e) {
+            throw new GeneratorException($e->getErrors(), $e);
+        }
+
+        if ($isTest) {
+            return $generatedResource;
+        }
+
+        /** @var StoredObject $storedObject */
+        $destinationStoredObject
+            ->setType($template->getFile()->getType())
+            ->setFilename(sprintf('%s_odt', uniqid('doc_', true)))
+            ->setStatus(StoredObject::STATUS_READY)
+            ;
+
+        $this->storedObjectManager->write($destinationStoredObject, $generatedResource);
+
+        try {
+            $context
+                ->storeGenerated(
+                    $template,
+                    $destinationStoredObject,
+                    $entity,
+                    $contextGenerationData
+                );
+        } catch (\Exception $e) {
+            $this
+                ->logger
+                ->error(
+                    'Unable to store the associated document to entity',
+                    [
+                        'entityClassName' => $entityClassName,
+                        'entityId' => $entityId,
+                        'contextKey' => $context->getName(),
+                    ]
+                );
+
+            throw $e;
+        }
+
+        $this->entityManager->flush();
+
+        return null;
+    }
+}
--- a/src/Bundle/ChillDocGeneratorBundle/Service/Generator/GeneratorException.php
+++ b/src/Bundle/ChillDocGeneratorBundle/Service/Generator/GeneratorException.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Chill\DocGeneratorBundle\Service\Generator;
+
+class GeneratorException extends \RuntimeException
+{
+    /**
+     * @var list<string>
+     */
+    private array $errors;
+
+    public function __construct(array $errors = [], \Throwable $previous = null)
+    {
+        $this->errors = $errors;
+        parent::__construct("Could not generate the document", 15252,
+            $previous);
+    }
+}
--- a/src/Bundle/ChillDocGeneratorBundle/Service/Generator/ObjectReadyException.php
+++ b/src/Bundle/ChillDocGeneratorBundle/Service/Generator/ObjectReadyException.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace Chill\DocGeneratorBundle\Service\Generator;
+
+class ObjectReadyException extends \RuntimeException
+{
+    public function __construct()
+    {
+        parent::__construct("object is already ready", 6698856);
+    }
+}
--- a/src/Bundle/ChillDocGeneratorBundle/Service/Generator/RelatedEntityNotFoundException.php
+++ b/src/Bundle/ChillDocGeneratorBundle/Service/Generator/RelatedEntityNotFoundException.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Chill\DocGeneratorBundle\Service\Generator;
+
+class RelatedEntityNotFoundException extends \RuntimeException
+{
+    public function __construct(string $relatedEntityClass, int $relatedEntityId, Throwable $previous = null)
+    {
+        parent::__construct(
+            sprintf("Related entity not found: %s, %s", $relatedEntityClass, $relatedEntityId),
+            99876652,
+            $previous);
+    }
+}
--- a/src/Bundle/ChillDocGeneratorBundle/Service/Messenger/RequestGenerationMessage.php
+++ b/src/Bundle/ChillDocGeneratorBundle/Service/Messenger/RequestGenerationMessage.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace Chill\DocGeneratorBundle\Service\Messenger;
+
+use Chill\DocGeneratorBundle\Entity\DocGeneratorTemplate;
+use Chill\MainBundle\Entity\User;
+
+class RequestGenerationMessage
+{
+   private int $creatorId;
+
+   private int $templateId;
+
+   private int $entityId;
+
+   private string $entityClassName;
+
+    public function __construct(User $creator, DocGeneratorTemplate $template, int $entityId, string $entityClassName)
+    {
+        $this->creatorId = $creator->getId();
+        $this->templateId = $template->getId();
+        $this->entityId = $entityId;
+        $this->entityClassName = $entityClassName;
+    }
+
+    public function getCreatorId(): int
+    {
+        return $this->creatorId;
+    }
+
+    public function getTemplateId(): int
+    {
+        return $this->templateId;
+    }
+
+    public function getEntityId(): int
+    {
+        return $this->entityId;
+    }
+
+    public function getEntityClassName(): string
+    {
+        return $this->entityClassName;
+    }
+}
--- a/src/Bundle/ChillDocGeneratorBundle/tests/Service/Context/Generator/GeneratorTest.php
+++ b/src/Bundle/ChillDocGeneratorBundle/tests/Service/Context/Generator/GeneratorTest.php
@@ -0,0 +1,134 @@
+<?php
+
+namespace Chill\DocGeneratorBundle\tests\Service\Context\Generator;
+
+use Chill\DocGeneratorBundle\Context\ContextManagerInterface;
+use Chill\DocGeneratorBundle\Context\DocGeneratorContextInterface;
+use Chill\DocGeneratorBundle\Entity\DocGeneratorTemplate;
+use Chill\DocGeneratorBundle\GeneratorDriver\DriverInterface;
+use Chill\DocGeneratorBundle\Service\Generator\Generator;
+use Chill\DocGeneratorBundle\Service\Generator\ObjectReadyException;
+use Chill\DocGeneratorBundle\Service\Generator\RelatedEntityNotFoundException;
+use Chill\DocStoreBundle\Entity\StoredObject;
+use Chill\DocStoreBundle\Service\StoredObjectManagerInterface;
+use Doctrine\ORM\EntityManagerInterface;
+use PHPUnit\Framework\TestCase;
+use Prophecy\Argument;
+use Prophecy\PhpUnit\ProphecyTrait;
+use Psr\Log\NullLogger;
+
+class GeneratorTest extends TestCase
+{
+    use ProphecyTrait;
+
+    public function testSuccessfulGeneration(): void
+    {
+        $template = (new DocGeneratorTemplate())->setFile($templateStoredObject = (new StoredObject())
+            ->setType('application/test'));
+        $destinationStoredObject = (new StoredObject())->setStatus(StoredObject::STATUS_PENDING);
+        $entity = new class {};
+        $data = [];
+
+        $context = $this->prophesize(DocGeneratorContextInterface::class);
+        $context->getData($template, $entity, Argument::type('array'))->willReturn($data);
+        $context->storeGenerated($template, $destinationStoredObject, $entity, Argument::type('array'))
+            ->shouldBeCalled();
+        $context->getName()->willReturn('dummy_context');
+        $context->getEntityClass()->willReturn('DummyClass');
+        $context = $context->reveal();
+
+        $contextManagerInterface = $this->prophesize(ContextManagerInterface::class);
+        $contextManagerInterface->getContextByDocGeneratorTemplate($template)
+            ->willReturn($context);
+
+        $driver = $this->prophesize(DriverInterface::class);
+        $driver->generateFromString('template', 'application/test', $data, Argument::any())
+            ->willReturn('generated');
+
+        $entityManager = $this->prophesize(EntityManagerInterface::class);
+        $entityManager->find(Argument::type('string'), Argument::type('int'))
+            ->willReturn($entity);
+        $entityManager->flush()->shouldBeCalled();
+
+        $storedObjectManager = $this->prophesize(StoredObjectManagerInterface::class);
+        $storedObjectManager->read($templateStoredObject)->willReturn('template');
+        $storedObjectManager->write($destinationStoredObject, 'generated')->shouldBeCalled();
+
+
+        $generator = new Generator(
+            $contextManagerInterface->reveal(),
+            $driver->reveal(),
+            $entityManager->reveal(),
+            new NullLogger(),
+            $storedObjectManager->reveal()
+        );
+
+        $generator->generateDocFromTemplate(
+            $template,
+            'DummyEntity',
+            1,
+            $destinationStoredObject
+        );
+    }
+
+    public function testPreventRegenerateDocument(): void
+    {
+        $this->expectException(ObjectReadyException::class);
+
+        $generator = new Generator(
+            $this->prophesize(ContextManagerInterface::class)->reveal(),
+            $this->prophesize(DriverInterface::class)->reveal(),
+            $this->prophesize(EntityManagerInterface::class)->reveal(),
+            new NullLogger(),
+            $this->prophesize(StoredObjectManagerInterface::class)->reveal()
+        );
+
+        $template = (new DocGeneratorTemplate())->setFile($templateStoredObject = (new StoredObject())
+            ->setType('application/test'));
+        $destinationStoredObject = (new StoredObject())->setStatus(StoredObject::STATUS_READY);
+
+        $generator->generateDocFromTemplate(
+            $template,
+            'DummyEntity',
+            1,
+            $destinationStoredObject
+        );
+    }
+
+    public function testRelatedEntityNotFound(): void
+    {
+        $this->expectException(RelatedEntityNotFoundException::class);
+
+        $template = (new DocGeneratorTemplate())->setFile($templateStoredObject = (new StoredObject())
+            ->setType('application/test'));
+        $destinationStoredObject = (new StoredObject())->setStatus(StoredObject::STATUS_PENDING);
+
+        $context = $this->prophesize(DocGeneratorContextInterface::class);
+        $context->getName()->willReturn('dummy_context');
+        $context->getEntityClass()->willReturn('DummyClass');
+        $context = $context->reveal();
+
+        $contextManagerInterface = $this->prophesize(ContextManagerInterface::class);
+        $contextManagerInterface->getContextByDocGeneratorTemplate($template)
+            ->willReturn($context);
+
+        $entityManager = $this->prophesize(EntityManagerInterface::class);
+        $entityManager->find(Argument::type('string'), Argument::type('int'))
+            ->willReturn(null);
+
+        $generator = new Generator(
+            $contextManagerInterface->reveal(),
+            $this->prophesize(DriverInterface::class)->reveal(),
+            $entityManager->reveal(),
+            new NullLogger(),
+            $this->prophesize(StoredObjectManagerInterface::class)->reveal()
+        );
+
+        $generator->generateDocFromTemplate(
+            $template,
+            'DummyEntity',
+            1,
+            $destinationStoredObject
+        );
+    }
+}