Step 19: Making Decisions with a Workflow

Making Decisions with a Workflow

We might want to let the website admin moderate all comments after the spam checker. The process would be something along the lines of:

  • Start with a state when a comment is submitted by a user;
  • Let the spam checker analyze the comment and switch the state to either potential_spam, ham, or rejected;
  • If not rejected, wait for the website admin to decide if the comment is good enough by switching the state to published or rejected.

Implementing this logic is not too complex, but you can imagine that adding more rules would greatly increase the complexity. Instead of coding the logic ourselves, we can use the Symfony Workflow Component:

The comment workflow can be described in the config/packages/workflow.yaml file:

config/packages/workflow.yaml

  1. framework:
  2.     workflows:
  3.         comment:
  4.             type: state_machine
  5.             audit_trail:
  6.                 enabled: "%kernel.debug%"
  7.             marking_store:
  8.                 type: 'method'
  9.                 property: 'state'
  10.             supports:
  11.                 - App\Entity\Comment
  12.             initial_marking: submitted
  13.             places:
  14.                 - submitted
  15.                 - ham
  16.                 - potential_spam
  17.                 - spam
  18.                 - rejected
  19.                 - published
  20.             transitions:
  21.                 accept:
  22.                     from: submitted
  23.                     to:   ham
  24.                 might_be_spam:
  25.                     from: submitted
  26.                     to:   potential_spam
  27.                 reject_spam:
  28.                     from: submitted
  29.                     to:   spam
  30.                 publish:
  31.                     from: potential_spam
  32.                     to:   published
  33.                     from: potential_spam
  34.                     to:   rejected
  35.                 publish_ham:
  36.                     from: ham
  37.                     to:   published
  38.                 reject_ham:
  40.                     to:   rejected

To validate the workflow, generate a visual representation:

Note

Replace the current logic in the message handler with the workflow:

patch_file

  1. --- a/src/MessageHandler/CommentMessageHandler.php
  2. +++ b/src/MessageHandler/CommentMessageHandler.php
  3. @@ -6,19 +6,28 @@ use App\Message\CommentMessage;
  4.  use App\Repository\CommentRepository;
  5.  use App\SpamChecker;
  6.  use Doctrine\ORM\EntityManagerInterface;
  7. +use Psr\Log\LoggerInterface;
  8.  use Symfony\Component\Messenger\Handler\MessageHandlerInterface;
  9. +use Symfony\Component\Messenger\MessageBusInterface;
  10. +use Symfony\Component\Workflow\WorkflowInterface;
  12.  class CommentMessageHandler implements MessageHandlerInterface
  13.  {
  14.      private $spamChecker;
  15.      private $entityManager;
  16.      private $commentRepository;
  17. +    private $bus;
  18. +    private $workflow;
  19. +    private $logger;
  21. -    public function __construct(EntityManagerInterface $entityManager, SpamChecker $spamChecker, CommentRepository $commentRepository)
  22. +    public function __construct(EntityManagerInterface $entityManager, SpamChecker $spamChecker, CommentRepository $commentRepository, MessageBusInterface $bus, WorkflowInterface $commentStateMachine, LoggerInterface $logger = null)
  23.      {
  24.          $this->entityManager = $entityManager;
  25.          $this->spamChecker = $spamChecker;
  26.          $this->commentRepository = $commentRepository;
  27. +        $this->bus = $bus;
  28. +        $this->workflow = $commentStateMachine;
  29. +        $this->logger = $logger;
  30.      }
  32.      public function __invoke(CommentMessage $message)
  33. @@ -28,12 +37,21 @@ class CommentMessageHandler implements MessageHandlerInterface
  34.              return;
  35.          }
  36. -        if (2 === $this->spamChecker->getSpamScore($comment, $message->getContext())) {
  37. -            $comment->setState('spam');
  38. -        } else {
  39. -            $comment->setState('published');
  40. -        }
  42. -        $this->entityManager->flush();
  44. +            $score = $this->spamChecker->getSpamScore($comment, $message->getContext());
  45. +            $transition = 'accept';
  46. +            if (2 === $score) {
  47. +                $transition = 'reject_spam';
  48. +            } elseif (1 === $score) {
  49. +                $transition = 'might_be_spam';
  50. +            }
  51. +            $this->workflow->apply($comment, $transition);
  52. +            $this->entityManager->flush();
  53. +
  54. +            $this->bus->dispatch($message);
  55. +        } elseif ($this->logger) {
  56. +            $this->logger->debug('Dropping comment message', ['comment' => $comment->getId(), 'state' => $comment->getState()]);
  57. +        }
  58.      }
  59.  }

The new logic reads as follows:

  • If the accept transition is available for the comment in the message, check for spam;
  • Depending on the outcome, choose the right transition to apply;
  • Call apply() to update the Comment via a call to the setState() method;
  • Call flush() to commit the changes to the database;
  • Re-dispatch the message to allow the workflow to transition again.

As we haven’t implemented the admin validation, the next time the message is consumed, the “Dropping comment message” will be logged.

Let’s implement an auto-validation until the next chapter:

patch_file

Run symfony server:log and add a comment in the frontend to see all transitions happening one after the other.

We have just come across such an example with the injection of a WorkflowInterface in the previous section.

As we inject any instance of the generic WorkflowInterface interface in the contructor, how can Symfony guess which workflow implementation to use? Symfony uses a convention based one the argument name: $commentStateMachine refers to the comment workflow in the configuration (which type is state_machine). Try any other argument name and it will fail.

If you don’t remember the convention, use the debug:container command. Search for all services containing “workflow”:

  1. $ symfony console debug:container workflow
  3.  Select one of the following services to display its information:
  4.   [0] console.command.workflow_dump
  5.   [1] workflow.abstract
  6.   [2] workflow.marking_store.method
  7.   [3] workflow.registry
  8.   [4] workflow.security.expression_language
  9.   [5] workflow.twig_extension
  10.   [6] monolog.logger.workflow
  11.   [7] Symfony\Component\Workflow\Registry
  12.   [8] Symfony\Component\Workflow\WorkflowInterface $commentStateMachine
  13.   [9] Psr\Log\LoggerInterface $workflowLogger
  14.  >

Notice choice 8, Symfony\Component\Workflow\WorkflowInterface $commentStateMachine which tells you that using $commentStateMachine as an argument name has a special meaning.

Note

We could have used the debug:autowiring command as seen in a previous chapter:

Going Further

  • The .