Merge branch '295-cancel-workflow-after-90-days' into 'signature-app-master'

Create CancelStaleWorkflow message, handler and cronjob

See merge request Chill-Projet/chill-bundles!720

src/Bundle/ChillMainBundle/Entity/Workflow/EntityWorkflow.php

@@ -38,7 +38,7 @@ class EntityWorkflow implements TrackCreationInterface, TrackUpdateInterface
     /**
      * @var Collection<int, \Chill\MainBundle\Entity\Workflow\EntityWorkflowComment>
      */
-    #[ORM\OneToMany(targetEntity: EntityWorkflowComment::class, mappedBy: 'entityWorkflow', orphanRemoval: true)]
+    #[ORM\OneToMany(mappedBy: 'entityWorkflow', targetEntity: EntityWorkflowComment::class, orphanRemoval: true)]
     private Collection $comments;
 
     #[ORM\Id]
@@ -56,7 +56,7 @@ class EntityWorkflow implements TrackCreationInterface, TrackUpdateInterface
      * @var Collection<int, EntityWorkflowStep>&Selectable<int, EntityWorkflowStep>
      */
     #[Assert\Valid(traverse: true)]
-    #[ORM\OneToMany(mappedBy: 'entityWorkflow', targetEntity: EntityWorkflowStep::class, cascade: ['persist'], orphanRemoval: true)]
+    #[ORM\OneToMany(mappedBy: 'entityWorkflow', targetEntity: EntityWorkflowStep::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
     #[ORM\OrderBy(['transitionAt' => \Doctrine\Common\Collections\Criteria::ASC, 'id' => 'ASC'])]
     private Collection&Selectable $steps;
 
@@ -488,4 +488,36 @@ class EntityWorkflow implements TrackCreationInterface, TrackUpdateInterface
     {
         return $this->getCurrentStep()->getHoldsOnStep()->count() > 0;
     }
+
+    /**
+     * Determines if the workflow has become stale after a given date.
+     *
+     * This function checks the creation date and the transition states of the workflow steps.
+     * A workflow is considered stale if:
+     * - The creation date is before the given date and no transitions have occurred since the creation.
+     * - Or if there are no transitions after the given date.
+     *
+     * @param \DateTimeImmutable $at the date to compare against the workflow's status
+     *
+     * @return bool true if the workflow is stale after the given date, false otherwise
+     */
+    public function isStaledAt(\DateTimeImmutable $at): bool
+    {
+        // if there is no transition since the creation, then the workflow is staled
+        if ('initial' === $this->getCurrentStep()->getCurrentStep()
+            && null === $this->getCurrentStep()->getTransitionAt()
+        ) {
+            if (null === $this->getCreatedAt()) {
+                return false;
+            }
+
+            if ($this->getCreatedAt() < $at) {
+                return true;
+            }
+
+            return false;
+        }
+
+        return $this->getCurrentStepChained()->getPrevious()->getTransitionAt() < $at;
+    }
 }

src/Bundle/ChillMainBundle/Repository/Workflow/EntityWorkflowRepository.php

@@ -198,6 +198,34 @@ class EntityWorkflowRepository implements ObjectRepository
         return $this->repository->findOneBy($criteria);
     }
 
+    /**
+     * Finds workflows that are not finalized and are older than the specified date.
+     *
+     * @param \DateTimeImmutable $olderThanDate the date to compare against
+     *
+     * @return list<int> the list of workflow IDs that meet the criteria
+     */
+    public function findWorkflowsWithoutFinalStepAndOlderThan(\DateTimeImmutable $olderThanDate): array
+    {
+        $qb = $this->repository->createQueryBuilder('sw');
+
+        $qb->select('sw.id')
+            // only the workflow which are not finalized
+            ->where('NOT EXISTS (SELECT 1 FROM chill_main_entity_workflow_step ews WHERE ews.isFinal = TRUE AND ews.entityWorkflow = sw.id)')
+            ->andWhere(
+                $qb->expr()->orX(
+                    // only the workflow where all the last transition is older than transitionAt
+                    ':olderThanDate > ALL (SELECT ews.transitionAt FROM chill_main_entity_workflow_step ews WHERE ews.transitionAt IS NOT NULL AND ews.entityWorkflow = sw.id)',
+                    // or the workflow which have only the initial step, with no transition
+                    '1 = (SELECT COUNT(ews.id) FROM chill_main_entity_workflow_step ews WHERE ews.step = :initial AND ews.transitionAt IS NULL AND ews.createdAt < :olderThanDate AND ews.entityWorkflow = sw.id)',
+                )
+            )
+            ->andWhere('sw.createdAt < :olderThanDate')
+            ->setParameter('olderThanDate', $olderThanDate);
+
+        return $qb->getQuery()->getResult();
+    }
+
     public function getClassName(): string
     {
         return EntityWorkflow::class;

src/Bundle/ChillMainBundle/Service/Workflow/CancelStaleWorkflowCronJob.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * 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.
+ */
+
+namespace Chill\MainBundle\Service\Workflow;
+
+use Chill\MainBundle\Cron\CronJobInterface;
+use Chill\MainBundle\Entity\CronJobExecution;
+use Chill\MainBundle\Repository\Workflow\EntityWorkflowRepository;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\Clock\ClockInterface;
+use Symfony\Component\Messenger\MessageBusInterface;
+
+class CancelStaleWorkflowCronJob implements CronJobInterface
+{
+    public const KEY = 'remove-stale-workflow';
+
+    public const KEEP_INTERVAL = 'P90D';
+
+    private const LAST_CANCELED_WORKFLOW = 'last-canceled-workflow-id';
+
+    public function __construct(
+        private readonly EntityWorkflowRepository $workflowRepository,
+        private readonly ClockInterface $clock,
+        private readonly MessageBusInterface $messageBus,
+        private readonly LoggerInterface $logger,
+    ) {}
+
+    public function canRun(?CronJobExecution $cronJobExecution): bool
+    {
+        return $this->clock->now() >= $cronJobExecution->getLastEnd()->add(new \DateInterval('P1D'));
+    }
+
+    public function getKey(): string
+    {
+        return self::KEY;
+    }
+
+    public function run(array $lastExecutionData): ?array
+    {
+        $this->logger->info('Cronjob started: Canceling stale workflows.');
+
+        $olderThanDate = $this->clock->now()->sub(new \DateInterval(self::KEEP_INTERVAL));
+        $staleWorkflowIds = $this->workflowRepository->findWorkflowsWithoutFinalStepAndOlderThan($olderThanDate);
+        $lastCanceled = $lastExecutionData[self::LAST_CANCELED_WORKFLOW] ?? 0;
+        $processedCount = 0;
+
+        foreach ($staleWorkflowIds as $wId) {
+            try {
+                $this->messageBus->dispatch(new CancelStaleWorkflowMessage($wId));
+                $lastCanceled = max($wId, $lastCanceled);
+                ++$processedCount;
+            } catch (\Exception $e) {
+                $this->logger->error("Failed to dispatch CancelStaleWorkflow for ID {$wId}", ['exception' => $e]);
+                continue;
+            }
+        }
+
+        $this->logger->info("Cronjob completed: {$processedCount} workflows processed.");
+
+        return [self::LAST_CANCELED_WORKFLOW => $lastCanceled];
+    }
+}

src/Bundle/ChillMainBundle/Service/Workflow/CancelStaleWorkflowHandler.php

@@ -0,0 +1,88 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * 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.
+ */
+
+namespace Chill\MainBundle\Service\Workflow;
+
+use Chill\MainBundle\Repository\Workflow\EntityWorkflowRepository;
+use Chill\MainBundle\Workflow\WorkflowTransitionContextDTO;
+use Doctrine\ORM\EntityManagerInterface;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\Clock\ClockInterface;
+use Symfony\Component\Messenger\Attribute\AsMessageHandler;
+use Symfony\Component\Messenger\Exception\UnrecoverableMessageHandlingException;
+use Symfony\Component\Workflow\Registry;
+
+#[AsMessageHandler]
+final readonly class CancelStaleWorkflowHandler
+{
+    public function __construct(
+        private EntityWorkflowRepository $workflowRepository,
+        private Registry $registry,
+        private EntityManagerInterface $em,
+        private LoggerInterface $logger,
+        private ClockInterface $clock,
+    ) {}
+
+    public function __invoke(CancelStaleWorkflowMessage $message): void
+    {
+        $workflowId = $message->getWorkflowId();
+        $olderThanDate = $this->clock->now()->sub(new \DateInterval(CancelStaleWorkflowCronJob::KEEP_INTERVAL));
+
+        $workflow = $this->workflowRepository->find($message->getWorkflowId());
+        if (null === $workflow) {
+            $this->logger->alert('Workflow was not found!', [$workflowId]);
+
+            return;
+        }
+
+        if (false === $workflow->isStaledAt($olderThanDate)) {
+            $this->logger->alert('Workflow has transitioned in the meantime.', [$workflowId]);
+
+            throw new UnrecoverableMessageHandlingException('the workflow is not staled any more');
+        }
+
+        $workflowComponent = $this->registry->get($workflow, $workflow->getWorkflowName());
+        $metadataStore = $workflowComponent->getMetadataStore();
+        $transitions = $workflowComponent->getEnabledTransitions($workflow);
+
+        $transitionApplied = false;
+        $wasInInitialPosition = 'initial' === $workflow->getStep();
+
+        foreach ($transitions as $transition) {
+            $isFinal = $metadataStore->getMetadata('isFinal', $transition);
+            $isFinalPositive = $metadataStore->getMetadata('isFinalPositive', $transition);
+
+            if ($isFinal && !$isFinalPositive) {
+                $dto = new WorkflowTransitionContextDTO($workflow);
+                $workflowComponent->apply($workflow, $transition->getName(), [
+                    'context' => $dto,
+                    'byUser' => null,
+                    'transitionAt' => $this->clock->now(),
+                    'transition' => $transition->getName(),
+                ]);
+                $this->logger->info('EntityWorkflow has been cancelled automatically.', [$workflowId]);
+                $transitionApplied = true;
+                break;
+            }
+        }
+
+        if (!$transitionApplied) {
+            $this->logger->error('No valid transition found for EntityWorkflow.', [$workflowId]);
+            throw new UnrecoverableMessageHandlingException(sprintf('No valid transition found for EntityWorkflow %d.', $workflowId));
+        }
+
+        if ($wasInInitialPosition) {
+            $this->em->remove($workflow);
+        }
+
+        $this->em->flush();
+    }
+}

src/Bundle/ChillMainBundle/Service/Workflow/CancelStaleWorkflowMessage.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * 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.
+ */
+
+namespace Chill\MainBundle\Service\Workflow;
+
+class CancelStaleWorkflowMessage
+{
+    public function __construct(public int $workflowId) {}
+
+    public function getWorkflowId(): int
+    {
+        return $this->workflowId;
+    }
+}

src/Bundle/ChillMainBundle/Tests/Entity/Workflow/EntityWorkflowTest.php

@@ -138,4 +138,31 @@ final class EntityWorkflowTest extends TestCase
         self::assertContains($person1, $persons);
         self::assertContains($person2, $persons);
     }
+
+    public function testIsStaledAt(): void
+    {
+        $creationDate = new \DateTimeImmutable('2024-01-01');
+        $firstStepDate = new \DateTimeImmutable('2024-01-02');
+        $afterFistStep = new \DateTimeImmutable('2024-01-03');
+
+        $entityWorkflow = new EntityWorkflow();
+
+        self::assertFalse($entityWorkflow->isStaledAt($creationDate), 'an entityWorkflow with null createdAt date should never be staled at initial step');
+        self::assertFalse($entityWorkflow->isStaledAt($firstStepDate), 'an entityWorkflow with null createdAt date should never be staled at initial step');
+        self::assertFalse($entityWorkflow->isStaledAt($afterFistStep), 'an entityWorkflow with null createdAt date should never be staled at initial step');
+
+        $entityWorkflow->setCreatedAt($creationDate);
+
+        self::assertFalse($entityWorkflow->isStaledAt($creationDate), 'an entityWorkflow with no step after initial should be staled');
+        self::assertTrue($entityWorkflow->isStaledAt($firstStepDate), 'an entityWorkflow with no step after initial should be staled');
+        self::assertTrue($entityWorkflow->isStaledAt($afterFistStep), 'an entityWorkflow with no step after initial should be staled');
+
+        // apply a first step
+        $dto = new WorkflowTransitionContextDTO($entityWorkflow);
+        $entityWorkflow->setStep('new_step', $dto, 'to_new_step', $firstStepDate);
+
+        self::assertFalse($entityWorkflow->isStaledAt($creationDate));
+        self::assertFalse($entityWorkflow->isStaledAt($firstStepDate));
+        self::assertTrue($entityWorkflow->isStaledAt($afterFistStep));
+    }
 }

src/Bundle/ChillMainBundle/Tests/Services/Workflow/CancelStaleWorkflowCronJobTest.php

@@ -0,0 +1,104 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * 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.
+ */
+
+namespace Services\Workflow;
+
+use Chill\MainBundle\Entity\CronJobExecution;
+use Chill\MainBundle\Repository\Workflow\EntityWorkflowRepository;
+use Chill\MainBundle\Service\Workflow\CancelStaleWorkflowCronJob;
+use Chill\MainBundle\Service\Workflow\CancelStaleWorkflowMessage;
+use PHPUnit\Framework\MockObject\Exception;
+use PHPUnit\Framework\TestCase;
+use Psr\Log\LoggerInterface;
+use Psr\Log\NullLogger;
+use Symfony\Component\Clock\MockClock;
+use Symfony\Component\Messenger\Envelope;
+use Symfony\Component\Messenger\MessageBusInterface;
+
+/**
+ * @internal
+ *
+ * @coversNothing
+ */
+class CancelStaleWorkflowCronJobTest extends TestCase
+{
+    /**
+     * @dataProvider buildTestCanRunData
+     *
+     * @throws \Exception
+     */
+    public function testCanRun(?CronJobExecution $cronJobExecution, bool $expected): void
+    {
+        $clock = new MockClock(new \DateTimeImmutable('2024-01-01 00:00:00', new \DateTimeZone('+00:00')));
+        $logger = $this->createMock(LoggerInterface::class);
+
+        $cronJob = new CancelStaleWorkflowCronJob($this->createMock(EntityWorkflowRepository::class), $clock, $this->buildMessageBus(), $logger);
+
+        self::assertEquals($expected, $cronJob->canRun($cronJobExecution));
+    }
+
+    /**
+     * @throws \DateMalformedStringException
+     * @throws \DateInvalidTimeZoneException
+     * @throws \Exception|Exception
+     */
+    public function testRun(): void
+    {
+        $clock = new MockClock((new \DateTimeImmutable('now', new \DateTimeZone('+00:00')))->add(new \DateInterval('P120D')));
+        $workflowRepository = $this->createMock(EntityWorkflowRepository::class);
+
+        $workflowRepository->method('findWorkflowsWithoutFinalStepAndOlderThan')->willReturn([1, 3, 2]);
+        $messageBus = $this->buildMessageBus(true);
+
+        $cronJob = new CancelStaleWorkflowCronJob($workflowRepository, $clock, $messageBus, new NullLogger());
+
+        $results = $cronJob->run([]);
+
+        // Assert the result has the last canceled workflow ID
+        self::assertArrayHasKey('last-canceled-workflow-id', $results);
+        self::assertEquals(3, $results['last-canceled-workflow-id']);
+    }
+
+    /**
+     * @throws \Exception
+     */
+    public static function buildTestCanRunData(): iterable
+    {
+        yield [
+            (new CronJobExecution('last-canceled-workflow-id'))->setLastEnd(new \DateTimeImmutable('2023-12-31 00:00:00', new \DateTimeZone('+00:00'))),
+            true,
+        ];
+
+        yield [
+            (new CronJobExecution('last-canceled-workflow-id'))->setLastEnd(new \DateTimeImmutable('2023-12-30 23:59:59', new \DateTimeZone('+00:00'))),
+            true,
+        ];
+
+        yield [
+            (new CronJobExecution('last-canceled-workflow-id'))->setLastEnd(new \DateTimeImmutable('2023-12-31 00:00:01', new \DateTimeZone('+00:00'))),
+            false,
+        ];
+    }
+
+    private function buildMessageBus(bool $expectDispatchAtLeastOnce = false): MessageBusInterface
+    {
+        $messageBus = $this->createMock(MessageBusInterface::class);
+
+        $methodDispatch = match ($expectDispatchAtLeastOnce) {
+            true => $messageBus->expects($this->atLeastOnce())->method('dispatch')->with($this->isInstanceOf(CancelStaleWorkflowMessage::class)),
+            false => $messageBus->method('dispatch'),
+        };
+
+        $methodDispatch->willReturnCallback(fn (CancelStaleWorkflowMessage $message) => new Envelope($message));
+
+        return $messageBus;
+    }
+}

src/Bundle/ChillMainBundle/Tests/Services/Workflow/CancelStaleWorkflowHandlerTest.php

@@ -0,0 +1,161 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * 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.
+ */
+
+namespace Services\Workflow;
+
+use Chill\MainBundle\Entity\User;
+use Chill\MainBundle\Entity\Workflow\EntityWorkflow;
+use Chill\MainBundle\Repository\Workflow\EntityWorkflowRepository;
+use Chill\MainBundle\Service\Workflow\CancelStaleWorkflowHandler;
+use Chill\MainBundle\Service\Workflow\CancelStaleWorkflowMessage;
+use Chill\MainBundle\Workflow\EntityWorkflowMarkingStore;
+use Chill\MainBundle\Workflow\WorkflowTransitionContextDTO;
+use Doctrine\ORM\EntityManagerInterface;
+use PHPUnit\Framework\TestCase;
+use Prophecy\PhpUnit\ProphecyTrait;
+use Psr\Log\NullLogger;
+use Symfony\Component\Clock\ClockInterface;
+use Symfony\Component\Clock\MockClock;
+use Symfony\Component\Messenger\Exception\UnrecoverableMessageHandlingException;
+use Symfony\Component\Workflow\DefinitionBuilder;
+use Symfony\Component\Workflow\Metadata\InMemoryMetadataStore;
+use Symfony\Component\Workflow\Registry;
+use Symfony\Component\Workflow\SupportStrategy\WorkflowSupportStrategyInterface;
+use Symfony\Component\Workflow\Transition;
+use Symfony\Component\Workflow\Workflow;
+use Symfony\Component\Workflow\WorkflowInterface;
+
+/**
+ * @internal
+ *
+ * @coversNothing
+ */
+class CancelStaleWorkflowHandlerTest extends TestCase
+{
+    use ProphecyTrait;
+
+    public function testWorkflowWithOneStepOlderThan90DaysIsCanceled(): void
+    {
+        $clock = new MockClock('2024-01-01');
+        $daysAgos = new \DateTimeImmutable('2023-09-01');
+
+        $workflow = new EntityWorkflow();
+        $workflow->setWorkflowName('dummy_workflow');
+        $workflow->setCreatedAt(new \DateTimeImmutable('2023-09-01'));
+        $workflow->setStep('step1', new WorkflowTransitionContextDTO($workflow), 'to_step1', $daysAgos, new User());
+
+        $em = $this->prophesize(EntityManagerInterface::class);
+        $em->flush()->shouldBeCalled();
+        $em->remove($workflow)->shouldNotBeCalled();
+
+        $handler = $this->buildHandler($workflow, $em->reveal(), $clock);
+
+        $handler(new CancelStaleWorkflowMessage(1));
+
+        self::assertEquals('canceled', $workflow->getStep());
+        self::assertCount(3, $workflow->getSteps());
+    }
+
+    public function testWorkflowNotInStaledHandlerIsUnrecoverable(): void
+    {
+        $this->expectException(UnrecoverableMessageHandlingException::class);
+
+        $clock = new MockClock('2024-01-01');
+        $daysAgos = new \DateTimeImmutable('2023-12-31');
+
+        $workflow = new EntityWorkflow();
+        $workflow->setWorkflowName('dummy_workflow');
+        $workflow->setCreatedAt(new \DateTimeImmutable('2023-12-31'));
+        $workflow->setStep('step1', new WorkflowTransitionContextDTO($workflow), 'to_step1', $daysAgos, new User());
+
+        $em = $this->prophesize(EntityManagerInterface::class);
+        $em->flush()->shouldNotBeCalled();
+        $em->remove($workflow)->shouldNotBeCalled();
+
+        $handler = $this->buildHandler($workflow, $em->reveal(), $clock);
+
+        $handler(new CancelStaleWorkflowMessage(1));
+
+        self::assertEquals('canceled', $workflow->getStep());
+        self::assertCount(3, $workflow->getSteps());
+    }
+
+    public function testWorkflowStaledInInitialStateIsCompletelyRemoved(): void
+    {
+        $clock = new MockClock('2024-01-01');
+
+        $workflow = new EntityWorkflow();
+        $workflow->setWorkflowName('dummy_workflow');
+        $workflow->setCreatedAt(new \DateTimeImmutable('2023-09-01'));
+
+        $em = $this->prophesize(EntityManagerInterface::class);
+        $em->flush()->shouldBeCalled();
+        $em->remove($workflow)->shouldBeCalled();
+
+        $handler = $this->buildHandler($workflow, $em->reveal(), $clock);
+
+        $handler(new CancelStaleWorkflowMessage(1));
+
+        self::assertEquals('canceled', $workflow->getStep());
+        self::assertCount(2, $workflow->getSteps());
+    }
+
+    private function buildHandler(
+        EntityWorkflow $entityWorkflow,
+        EntityManagerInterface $entityManager,
+        ClockInterface $clock,
+    ): CancelStaleWorkflowHandler {
+        // set an id for the workflow
+        $reflection = new \ReflectionClass($entityWorkflow);
+        $reflection->getProperty('id')->setValue($entityWorkflow, 1);
+
+        $repository = $this->prophesize(EntityWorkflowRepository::class);
+        $repository->find(1)->willReturn($entityWorkflow);
+
+        return new CancelStaleWorkflowHandler($repository->reveal(), $this->buildRegistry(), $entityManager, new NullLogger(), $clock);
+    }
+
+    private function buildRegistry(): Registry
+    {
+        $definitionBuilder = new DefinitionBuilder();
+
+        $definitionBuilder
+            ->setInitialPlaces('initial')
+            ->addPlaces(['initial', 'step1', 'canceled', 'final'])
+            ->addTransition(new Transition('to_step1', 'initial', 'step1'))
+            ->addTransition($cancelInit = new Transition('cancel', 'initial', 'canceled'))
+            ->addTransition($finalizeInit = new Transition('finalize', 'initial', 'final'))
+            ->addTransition($cancelStep1 = new Transition('cancel', 'step1', 'canceled'))
+            ->addTransition($finalizeStep1 = new Transition('finalize', 'step1', 'final'));
+
+        $transitionStorage = new \SplObjectStorage();
+        $transitionStorage->attach($finalizeInit, ['isFinal' => true, 'isFinalPositive' => true]);
+        $transitionStorage->attach($cancelInit, ['isFinal' => true, 'isFinalPositive' => false]);
+        $transitionStorage->attach($finalizeStep1, ['isFinal' => true, 'isFinalPositive' => true]);
+        $transitionStorage->attach($cancelStep1, ['isFinal' => true, 'isFinalPositive' => false]);
+
+        $definitionBuilder->setMetadataStore(new InMemoryMetadataStore([], [], $transitionStorage));
+        $workflow = new Workflow($definitionBuilder->build(), new EntityWorkflowMarkingStore(), null, 'dummy_workflow');
+        $supports =
+            new class () implements WorkflowSupportStrategyInterface {
+                public function supports(WorkflowInterface $workflow, object $subject): bool
+                {
+                    return true;
+                }
+            };
+
+
+        $registry = new Registry();
+        $registry->addWorkflow($workflow, $supports);
+
+        return $registry;
+    }
+}