src/Subscriber/Messenger/MessageSubscriber.php line 68

Open in your IDE?
  1. <?php
  3. namespace App\Subscriber\Messenger;
  5. use App\Event\Messenger\ConversationMessagePreconditionCheckEvent;
  6. use App\Event\Messenger\FilterNewMessageEvent;
  7. use App\Exception\Messaging\MessageBlockedUntilException;
  8. use App\Exception\Purchase\CoinsLockedException;
  9. use App\Exception\Purchase\InsufficientCoinsException;
  10. use App\Exception\User\MemberBlockedException;
  11. use App\Repository\ConversationMessageRepository;
  12. use App\Service\Messenger\SpamDetectorService;
  13. use App\Service\Payment\PurchaseService;
  14. use App\Service\User\BalanceMemberService;
  15. use App\Service\User\MemberBlockedService;
  16. use Doctrine\ORM\NonUniqueResultException;
  17. use Doctrine\ORM\NoResultException;
  18. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  20. class MessageSubscriber implements EventSubscriberInterface
  21. {
  22.     public function __construct(
  23.         private readonly BalanceMemberService $balanceMemberService,
  24.         private readonly PurchaseService $purchaseService,
  25.         private readonly SpamDetectorService $spamDetector,
  26.         private readonly MemberBlockedService $blockedService,
  27.         private readonly ConversationMessageRepository $messageRepository
  28.     ) {
  29.     }
  31.     public static function getSubscribedEvents(): array
  32.     {
  33.         return [
  34.             ConversationMessagePreconditionCheckEvent::class => [
  35.                 ['checkCanMessageUser', 0],
  36.                 ['checkMemberBlocked', 1],
  37.                 ['checkSufficientCoins', 2],
  38.             ],
  39.             FilterNewMessageEvent::class => [
  40.                 ['onNewMessageDetectSpam', 0],
  41.             ],
  42.         ];
  43.     }
  45.     /**
  46.      * @throws MessageBlockedUntilException
  47.      * @throws NonUniqueResultException
  48.      * @throws NoResultException
  49.      */
  50.     public function checkCanMessageUser(ConversationMessagePreconditionCheckEvent $event): void
  51.     {
  52.         $message = $event->getEntity();
  53.         $sender = $message->getMember();
  54.         $recipient = $message->getRecipient();
  56.         $status = $this->messageRepository->canMessageUser($sender, $recipient);
  58.         if (!$status->isSendable()) {
  59.             $error = new MessageBlockedUntilException($status->getBlockedUntil());
  60.             $event->setStopReason($error->getMessage());
  61.             throw $error;
  62.         }
  63.     }
  65.     /**
  66.      * @throws MemberBlockedException
  67.      */
  68.     public function checkMemberBlocked(ConversationMessagePreconditionCheckEvent $event): void
  69.     {
  70.         $message = $event->getEntity();
  71.         $sender = $message->getMember();
  72.         $recipient = $message->getRecipient();
  74.         if ($block = $this->blockedService->findByOwnerAndTarget($recipient, $sender)) {
  75.             $error = new MemberBlockedException('Dieses Mitglied hat Dich blockiert.');
  76.             $event->setStopReason($error->getMessage());
  77.             throw $error;
  78.         }
  79.     }
  81.     /**
  82.      * @throws InsufficientCoinsException
  83.      * @throws NonUniqueResultException|CoinsLockedException
  84.      */
  85.     public function checkSufficientCoins(ConversationMessagePreconditionCheckEvent $event): void
  86.     {
  87.         $message = $event->getEntity();
  88.         $sender = $message->getMember();
  90.         // let through: sender is amateur, coins set to 0, system messages, messages from admins
  91.         if (!$message->needsToBePurchased()) {
  92.             return;
  93.         }
  95.         if (!$sender->getIsAmateur() && $this->purchaseService->areCoinsLockedForMember($sender)) {
  96.             $error = new CoinsLockedException($sender->getUsername());
  97.             $event->setStopReason($error->getEnduserMessage());
  98.             throw $error;
  99.         }
  101.         // check coins
  102.         $available = $this->balanceMemberService->getCoinsForMember($sender);
  103.         if ($available < $message->getCoins()) {
  104.             $error = new InsufficientCoinsException(
  105.                 $sender->getUsername(),
  106.                 $message->getCoins(),
  107.                 $available
  108.             );
  109.             $event->setStopReason($error->getEnduserMessage());
  110.             throw $error;
  111.         }
  112.     }
  114.     public function onNewMessageDetectSpam(FilterNewMessageEvent $event): void
  115.     {
  116.         if (!$event->mustUseSpamDetection()) {
  117.             return;
  118.         }
  120.         $message = $event->getEntity();
  122.         $text = $message->getMessage();
  123.         $hits = $this->spamDetector->parse($text);
  124.         if ($hits > 0) {
  125.             $message->setMessage($text);
  126.         }
  127.     }
  128. }