wip: refactor watchlist update and watchlist trigger URI for upsert

src/State/WatchListUpdateProcessor.php

@@ -7,11 +7,18 @@ use ApiPlatform\Metadata\Post;
 use ApiPlatform\State\ProcessorInterface;
 use App\Entity\Domain;
 use App\Entity\WatchList;
+use App\Notifier\TestChatNotification;
 use App\Repository\DomainRepository;
+use App\Service\ChatNotificationService;
+use App\Service\Connector\AbstractProvider;
 use App\Service\RDAPService;
+use Psr\Log\LoggerInterface;
 use Symfony\Bundle\SecurityBundle\Security;
 use Symfony\Component\DependencyInjection\Attribute\Autowire;
+use Symfony\Component\DependencyInjection\ContainerInterface;
 use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
 use Symfony\Component\HttpKernel\Exception\TooManyRequestsHttpException;
 use Symfony\Component\HttpKernel\KernelInterface;
 use Symfony\Component\RateLimiter\RateLimiterFactory;
@@ -19,14 +26,18 @@ use Symfony\Component\RateLimiter\RateLimiterFactory;
 class WatchListUpdateProcessor implements ProcessorInterface
 {
     public function __construct(
-        private readonly DomainRepository   $domainRepository,
-        private readonly RDAPService        $RDAPService,
-        private readonly KernelInterface    $kernel,
-        private readonly Security           $security,
-        private readonly RateLimiterFactory $rdapRequestsLimiter,
+        private readonly DomainRepository      $domainRepository,
+        private readonly RDAPService           $RDAPService,
+        private readonly KernelInterface       $kernel,
+        private readonly Security              $security,
+        private readonly RateLimiterFactory    $rdapRequestsLimiter,
         private readonly ParameterBagInterface $parameterBag,
         #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
-        private readonly ProcessorInterface $persistProcessor,
+        private readonly ProcessorInterface    $persistProcessor,
+        private readonly LoggerInterface       $logger,
+        private readonly ChatNotificationService $chatNotificationService,
+        #[Autowire(service: 'service_container')]
+        private readonly ContainerInterface $locator,
     )
     {}
 
@@ -39,30 +50,82 @@ class WatchListUpdateProcessor implements ProcessorInterface
      */
     public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): mixed
     {
-        foreach ($data->getDomains() as $ldhName) {
-            /** @var ?Domain $domain */
-            $domain = $this->domainRepository->findOneBy(['ldhName' => $ldhName]);
+        dd($data);
+        $user = $this->security->getUser();
 
-            if (null === $domain) {
-                $domain = $this->RDAPService->registerDomain($ldhName);
+        if ($this->parameterBag->get('limited_features')) {
+            if ($data->getDomains()->count() > (int) $this->parameterBag->get('limit_max_watchlist_domains')) {
+                $this->logger->notice('User {username} tried to update a Watchlist. The maximum number of domains has been reached for this Watchlist', [
+                    'username' => $user->getUserIdentifier(),
+                ]);
+                throw new AccessDeniedHttpException('You have exceeded the maximum number of domain names allowed in this Watchlist');
+            }
 
-                if (false === $this->kernel->isDebug() && true === $this->parameterBag->get('limited_features')) {
-                    $limiter = $this->rdapRequestsLimiter->create($this->security->getUser()->getUserIdentifier());
-                    $limit = $limiter->consume();
+            $userWatchLists = $user->getWatchLists();
 
-                    if (!$limit->isAccepted()) {
-                        throw new TooManyRequestsHttpException($limit->getRetryAfter()->getTimestamp() - time());
-                    }
+            /** @var Domain[] $trackedDomains */
+            $trackedDomains = $userWatchLists
+                ->filter(fn (WatchList $wl) => $wl->getToken() !== $data->getToken())
+                ->reduce(fn (array $acc, WatchList $wl) => [...$acc, ...$wl->getDomains()->toArray()], []);
+
+            /** @var Domain $domain */
+            foreach ($data->getDomains()->getIterator() as $domain) {
+                if (in_array($domain, $trackedDomains)) {
+                    $ldhName = $domain->getLdhName();
+                    $this->logger->notice('User {username} tried to update a watchlist with domain name {ldhName}. It is forbidden to register the same domain name twice with limited mode', [
+                        'username' => $user->getUserIdentifier(),
+                        'ldhName' => $ldhName,
+                    ]);
+
+                    throw new AccessDeniedHttpException("It is forbidden to register the same domain name twice in your watchlists with limited mode ($ldhName)");
                 }
             }
 
-            $data->addDomain($domain);
+            if (null !== $data->getWebhookDsn() && count($data->getWebhookDsn()) > (int) $this->parameterBag->get('limit_max_watchlist_webhooks')) {
+                $this->logger->notice('User {username} tried to update a Watchlist. The maximum number of webhooks has been reached.', [
+                    'username' => $user->getUserIdentifier(),
+                ]);
+                throw new AccessDeniedHttpException('You have exceeded the maximum number of webhooks allowed in this Watchlist');
+            }
         }
 
-        if ($operation instanceof Post) {
-            $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+        $this->chatNotificationService->sendChatNotification($data, new TestChatNotification());
+
+        if ($connector = $data->getConnector()) {
+            if (!$user->getConnectors()->contains($connector)) {
+                $this->logger->notice('The Connector ({connector}) does not belong to the user.', [
+                    'username' => $user->getUserIdentifier(),
+                    'connector' => $connector->getId(),
+                ]);
+                throw new AccessDeniedHttpException('You cannot create a Watchlist with a connector that does not belong to you');
+            }
+
+            /** @var Domain $domain */
+            foreach ($data->getDomains()->getIterator() as $domain) {
+                if ($domain->getDeleted()) {
+                    $ldhName = $domain->getLdhName();
+                    throw new BadRequestHttpException("To add a connector, no domain in this Watchlist must have already expired ($ldhName)");
+                }
+            }
+
+            $connectorProviderClass = $connector->getProvider()->getConnectorProvider();
+            /** @var AbstractProvider $connectorProvider */
+            $connectorProvider = $this->locator->get($connectorProviderClass);
+
+            $connectorProvider->authenticate($connector->getAuthData());
+            $supported = $connectorProvider->isSupported(...$data->getDomains()->toArray());
+
+            if (!$supported) {
+                $this->logger->notice('The Connector ({connector}) does not support all TLDs in this Watchlist', [
+                    'username' => $user->getUserIdentifier(),
+                    'connector' => $connector->getId(),
+                ]);
+                throw new BadRequestHttpException('This connector does not support all TLDs in this Watchlist');
+            }
         }
 
+        $this->persistProcessor->process($data, $operation, $uriVariables, $context);
+
         return $data;
     }
 }