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
This commit is contained in:
Julien Fastré 2024-09-09 13:27:12 +00:00
commit ccc11b1c1d
8 changed files with 534 additions and 2 deletions

View File

@ -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;
}
}

View File

@ -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;

View File

@ -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];
}
}

View File

@ -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();
}
}

View File

@ -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;
}
}

View File

@ -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));
}
}

View File

@ -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;
}
}

View File

@ -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;
}
}