Merged master

src/Controller/ConnectorController.php

@@ -2,17 +2,17 @@
 
 namespace App\Controller;
 
-use App\Config\Connector\ConnectorInterface;
 use App\Entity\Connector;
 use App\Entity\User;
+use App\Service\Connector\AbstractProvider;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\EntityManagerInterface;
 use Psr\Log\LoggerInterface;
 use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
 use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
 use Symfony\Component\Routing\Attribute\Route;
 use Symfony\Component\Serializer\SerializerInterface;
-use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
 use Symfony\Contracts\HttpClient\HttpClientInterface;
 
 class ConnectorController extends AbstractController
@@ -43,7 +43,6 @@ class ConnectorController extends AbstractController
 
     /**
      * @throws \Exception
-     * @throws TransportExceptionInterface
      */
     #[Route(
         path: '/api/connectors',
@@ -69,10 +68,10 @@ class ConnectorController extends AbstractController
         ]);
 
         if (null === $provider) {
-            throw new \Exception('Provider not found');
+            throw new BadRequestHttpException('Provider not found');
         }
 
-        /** @var ConnectorInterface $connectorProviderClass */
+        /** @var AbstractProvider $connectorProviderClass */
         $connectorProviderClass = $provider->getConnectorProvider();
 
         $authData = $connectorProviderClass::verifyAuthData($connector->getAuthData(), $client);

src/Controller/DomainRefreshController.php

@@ -4,7 +4,7 @@ namespace App\Controller;
 
 use App\Entity\Domain;
 use App\Entity\WatchList;
-use App\Message\ProcessDomainTrigger;
+use App\Message\SendDomainEventNotif;
 use App\Repository\DomainRepository;
 use App\Service\RDAPService;
 use Psr\Log\LoggerInterface;
@@ -25,7 +25,7 @@ class DomainRefreshController extends AbstractController
         private readonly RDAPService $RDAPService,
         private readonly RateLimiterFactory $rdapRequestsLimiter,
         private readonly MessageBusInterface $bus,
-        private readonly LoggerInterface $logger
+        private readonly LoggerInterface $logger, private readonly KernelInterface $kernel
     ) {
     }
 
@@ -35,8 +35,9 @@ class DomainRefreshController extends AbstractController
      * @throws ExceptionInterface
      * @throws \Exception
      * @throws HttpExceptionInterface
+     * @throws \Throwable
      */
-    public function __invoke(string $ldhName, KernelInterface $kernel): ?Domain
+    public function __invoke(string $ldhName, KernelInterface $kernel): Domain
     {
         $idnDomain = strtolower(idn_to_ascii($ldhName));
         $userId = $this->getUser()->getUserIdentifier();
@@ -53,7 +54,8 @@ class DomainRefreshController extends AbstractController
         if (null !== $domain
             && !$domain->getDeleted()
             && ($domain->getUpdatedAt()->diff(new \DateTimeImmutable('now'))->days < 7)
-            && !$this->RDAPService::isToBeWatchClosely($domain, $domain->getUpdatedAt())
+            && !$this->RDAPService::isToBeWatchClosely($domain)
+            && !$this->kernel->isDebug()
         ) {
             $this->logger->info('It is not necessary to update the information of the domain name {idnDomain} with the RDAP protocol.', [
                 'idnDomain' => $idnDomain,
@@ -79,7 +81,7 @@ class DomainRefreshController extends AbstractController
 
         /** @var WatchList $watchList */
         foreach ($watchLists as $watchList) {
-            $this->bus->dispatch(new ProcessDomainTrigger($watchList->getToken(), $domain->getLdhName(), $updatedAt));
+            $this->bus->dispatch(new SendDomainEventNotif($watchList->getToken(), $domain->getLdhName(), $updatedAt));
         }
 
         return $domain;

src/Controller/RegistrationController.php

@@ -75,6 +75,25 @@ class RegistrationController extends AbstractController
             )
         );
 
+        if (false === (bool) $this->getParameter('registration_verify_email')) {
+            $user->setVerified(true);
+        } else {
+            $email = $this->emailVerifier->sendEmailConfirmation('app_verify_email', $user,
+                (new TemplatedEmail())
+                    ->from(new Address($this->mailerSenderEmail, $this->mailerSenderName))
+                    ->to($user->getEmail())
+                    ->locale('en')
+                    ->subject('Please Confirm your Email')
+                    ->htmlTemplate('emails/success/confirmation_email.html.twig')
+            );
+
+            $signedUrl = (string) $email->getContext()['signedUrl'];
+            $this->logger->notice('The validation link for user {username} is {signedUrl}', [
+                'username' => $user->getUserIdentifier(),
+                'signedUrl' => $signedUrl,
+            ]);
+        }
+
         $this->em->persist($user);
         $this->em->flush();
 
@@ -82,15 +101,6 @@ class RegistrationController extends AbstractController
             'username' => $user->getUserIdentifier(),
         ]);
 
-        $this->emailVerifier->sendEmailConfirmation('app_verify_email', $user,
-            (new TemplatedEmail())
-                ->from(new Address($this->mailerSenderEmail, $this->mailerSenderName))
-                ->to($user->getEmail())
-                ->locale('en')
-                ->subject('Please Confirm your Email')
-                ->htmlTemplate('emails/success/confirmation_email.html.twig')
-        );
-
         return new Response(null, 201);
     }
 

src/Controller/StatisticsController.php

@@ -0,0 +1,80 @@
+<?php
+
+namespace App\Controller;
+
+use App\Entity\Statistics;
+use App\Repository\DomainRepository;
+use App\Repository\WatchListRepository;
+use Psr\Cache\CacheItemPoolInterface;
+use Psr\Cache\InvalidArgumentException;
+use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
+use Symfony\Component\HttpKernel\KernelInterface;
+
+class StatisticsController extends AbstractController
+{
+    public function __construct(
+        private readonly CacheItemPoolInterface $pool,
+        private readonly DomainRepository $domainRepository,
+        private readonly WatchListRepository $watchListRepository,
+        private readonly KernelInterface $kernel
+    ) {
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public function __invoke(): Statistics
+    {
+        $stats = new Statistics();
+
+        $stats
+            ->setRdapQueries($this->pool->getItem('stats.rdap_queries.count')->get() ?? 0)
+            ->setDomainPurchased($this->pool->getItem('stats.domain.purchased')->get() ?? 0)
+            ->setDomainPurchaseFailed($this->pool->getItem('stats.domain.purchase.failed')->get() ?? 0)
+            ->setAlertSent($this->pool->getItem('stats.alert.sent')->get() ?? 0)
+
+            ->setDomainTracked(
+                $this->getCachedItem('stats.domain.tracked', fn () => $this->watchListRepository->createQueryBuilder('w')
+                    ->join('w.domains', 'd')
+                    ->select('COUNT(DISTINCT d.ldhName)')
+                    ->where('d.deleted = FALSE')
+                    ->getQuery()->getSingleColumnResult()[0])
+            )
+            ->setDomainCount(
+                $this->getCachedItem('stats.domain.count', fn () => $this->domainRepository->createQueryBuilder('d')
+                    ->join('d.tld', 't')
+                    ->select('t.tld tld')
+                    ->addSelect('COUNT(d.ldhName) AS domain')
+                    ->addGroupBy('t.tld')
+                    ->where('d.deleted = FALSE')
+                    ->orderBy('domain', 'DESC')
+                    ->setMaxResults(5)
+                    ->getQuery()->getArrayResult())
+            )
+            ->setDomainCountTotal(
+                $this->getCachedItem('stats.domain.total', fn () => $this->domainRepository->count(['deleted' => false])
+                ));
+
+        return $stats;
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    private function getCachedItem(string $key, callable $getItemFunction)
+    {
+        $item = $this->pool->getItem($key);
+
+        if (!$item->isHit() || $this->kernel->isDebug()) {
+            $value = $getItemFunction();
+            $item
+                ->set($value)
+                ->expiresAfter(new \DateInterval('PT6H'));
+            $this->pool->save($item);
+
+            return $value;
+        } else {
+            return $item->get();
+        }
+    }
+}

src/Controller/WatchListController.php

@@ -2,14 +2,19 @@
 
 namespace App\Controller;
 
+use App\Entity\Connector;
 use App\Entity\Domain;
 use App\Entity\DomainEntity;
 use App\Entity\DomainEvent;
 use App\Entity\User;
 use App\Entity\WatchList;
+use App\Notifier\TestChatNotification;
 use App\Repository\WatchListRepository;
+use App\Service\ChatNotificationService;
+use App\Service\Connector\AbstractProvider;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Exception\ORMException;
 use Eluceo\iCal\Domain\Entity\Attendee;
 use Eluceo\iCal\Domain\Entity\Calendar;
 use Eluceo\iCal\Domain\Entity\Event;
@@ -22,6 +27,7 @@ use Eluceo\iCal\Domain\ValueObject\Timestamp;
 use Eluceo\iCal\Presentation\Component\Property;
 use Eluceo\iCal\Presentation\Component\Property\Value\TextValue;
 use Eluceo\iCal\Presentation\Factory\CalendarFactory;
+use Psr\Cache\CacheItemPoolInterface;
 use Psr\Log\LoggerInterface;
 use Sabre\VObject\EofException;
 use Sabre\VObject\InvalidDataException;
@@ -31,8 +37,11 @@ use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpFoundation\Response;
 use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+use Symfony\Component\HttpKernel\KernelInterface;
 use Symfony\Component\Routing\Attribute\Route;
 use Symfony\Component\Serializer\SerializerInterface;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
 
 class WatchListController extends AbstractController
 {
@@ -40,7 +49,11 @@ class WatchListController extends AbstractController
         private readonly SerializerInterface $serializer,
         private readonly EntityManagerInterface $em,
         private readonly WatchListRepository $watchListRepository,
-        private readonly LoggerInterface $logger
+        private readonly LoggerInterface $logger,
+        private readonly HttpClientInterface $httpClient,
+        private readonly CacheItemPoolInterface $cacheItemPool,
+        private readonly KernelInterface $kernel,
+        private readonly ChatNotificationService $chatNotificationService
     ) {
     }
 
@@ -69,8 +82,8 @@ class WatchListController extends AbstractController
          * This policy guarantees the equal probability of obtaining a domain name if it is requested by several users.
          */
         if ($this->getParameter('limited_features')) {
-            if ($watchList->getDomains()->count() >= (int) $this->getParameter('limit_max_watchlist_domains')) {
-                $this->logger->notice('User {username} tried to create a Watchlist. However, the maximum number of domains has been reached for this Watchlist', [
+            if ($watchList->getDomains()->count() > (int) $this->getParameter('limit_max_watchlist_domains')) {
+                $this->logger->notice('User {username} tried to create a Watchlist. The maximum number of domains has been reached.', [
                     'username' => $user->getUserIdentifier(),
                 ]);
                 throw new AccessDeniedHttpException('You have exceeded the maximum number of domain names allowed in this Watchlist');
@@ -78,7 +91,7 @@ class WatchListController extends AbstractController
 
             $userWatchLists = $user->getWatchLists();
             if ($userWatchLists->count() >= (int) $this->getParameter('limit_max_watchlist')) {
-                $this->logger->notice('User {username} tried to create a Watchlist. However, the maximum number of Watchlists has been reached.', [
+                $this->logger->notice('User {username} tried to create a Watchlist. The maximum number of Watchlists has been reached', [
                     'username' => $user->getUserIdentifier(),
                 ]);
                 throw new AccessDeniedHttpException('You have exceeded the maximum number of Watchlists allowed');
@@ -90,17 +103,29 @@ class WatchListController extends AbstractController
             /** @var Domain $domain */
             foreach ($watchList->getDomains()->getIterator() as $domain) {
                 if (in_array($domain, $trackedDomains)) {
-                    $this->logger->notice('User {username} tried to create a watchlist with domain name {ldhName}. However, it is forbidden to register the same domain name twice with limited mode.', [
+                    $ldhName = $domain->getLdhName();
+
+                    $this->logger->notice('User {username} tried to create a watchlist with domain name {ldhName}. It is forbidden to register the same domain name twice with limited mode', [
                         'username' => $user->getUserIdentifier(),
-                        'ldhName' => $domain->getLdhName(),
+                        'ldhName' => $ldhName,
                     ]);
 
-                    throw new AccessDeniedHttpException('It is forbidden to register the same domain name twice in your watchlists with limited mode.');
+                    throw new AccessDeniedHttpException("It is forbidden to register the same domain name twice in your watchlists with limited mode ($ldhName)");
                 }
             }
+
+            if (null !== $watchList->getWebhookDsn() && count($watchList->getWebhookDsn()) > (int) $this->getParameter('limit_max_watchlist_webhooks')) {
+                $this->logger->notice('User {username} tried to create 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');
+            }
         }
 
-        $this->logger->info('User {username} register a Watchlist ({token}).', [
+        $this->chatNotificationService->sendChatNotification($watchList, new TestChatNotification());
+        $this->verifyConnector($watchList, $watchList->getConnector());
+
+        $this->logger->info('User {username} registers a Watchlist ({token}).', [
             'username' => $user->getUserIdentifier(),
             'token' => $watchList->getToken(),
         ]);
@@ -111,6 +136,138 @@ class WatchListController extends AbstractController
         return $watchList;
     }
 
+    #[Route(
+        path: '/api/watchlists',
+        name: 'watchlist_get_all_mine',
+        defaults: [
+            '_api_resource_class' => WatchList::class,
+            '_api_operation_name' => 'get_all_mine',
+        ],
+        methods: ['GET']
+    )]
+    public function getWatchLists(): Collection
+    {
+        /** @var User $user */
+        $user = $this->getUser();
+
+        return $user->getWatchLists();
+    }
+
+    /**
+     * @throws \Exception
+     */
+    private function verifyConnector(WatchList $watchList, ?Connector $connector): void
+    {
+        /** @var User $user */
+        $user = $this->getUser();
+
+        if (null === $connector) {
+            return;
+        }
+        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 ($watchList->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 = new $connectorProviderClass($connector->getAuthData(), $this->httpClient, $this->cacheItemPool, $this->kernel);
+
+        $connectorProvider::verifyAuthData($connector->getAuthData(), $this->httpClient); // We want to check if the tokens are OK
+        $supported = $connectorProvider->isSupported(...$watchList->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');
+        }
+    }
+
+    /**
+     * @throws ORMException
+     * @throws \Exception
+     */
+    #[Route(
+        path: '/api/watchlists/{token}',
+        name: 'watchlist_update',
+        defaults: [
+            '_api_resource_class' => WatchList::class,
+            '_api_operation_name' => 'update',
+        ],
+        methods: ['PUT']
+    )]
+    public function putWatchList(WatchList $watchList): WatchList
+    {
+        /** @var User $user */
+        $user = $this->getUser();
+        $watchList->setUser($user);
+
+        if ($this->getParameter('limited_features')) {
+            if ($watchList->getDomains()->count() > (int) $this->getParameter('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');
+            }
+
+            $userWatchLists = $user->getWatchLists();
+
+            /** @var Domain[] $trackedDomains */
+            $trackedDomains = $userWatchLists
+                ->filter(fn (WatchList $wl) => $wl->getToken() !== $watchList->getToken())
+                ->reduce(fn (array $acc, WatchList $wl) => [...$acc, ...$wl->getDomains()->toArray()], []);
+
+            /** @var Domain $domain */
+            foreach ($watchList->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)");
+                }
+            }
+
+            if (null !== $watchList->getWebhookDsn() && count($watchList->getWebhookDsn()) > (int) $this->getParameter('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');
+            }
+        }
+
+        $this->chatNotificationService->sendChatNotification($watchList, new TestChatNotification());
+        $this->verifyConnector($watchList, $watchList->getConnector());
+
+        $this->logger->info('User {username} updates a Watchlist ({token}).', [
+            'username' => $user->getUserIdentifier(),
+            'token' => $watchList->getToken(),
+        ]);
+
+        $this->em->remove($this->em->getReference(WatchList::class, $watchList->getToken()));
+        $this->em->flush();
+
+        $this->em->persist($watchList);
+        $this->em->flush();
+
+        return $watchList;
+    }
+
     /**
      * @throws ParseException
      * @throws EofException
@@ -149,7 +306,7 @@ class WatchListController extends AbstractController
             }
 
             /** @var DomainEvent $event */
-            foreach ($domain->getEvents()->toArray() as $event) {
+            foreach ($domain->getEvents()->filter(fn (DomainEvent $e) => $e->getDate()->diff(new \DateTimeImmutable('now'))->y <= 10)->getIterator() as $event) {
                 $calendar->addEvent((new Event())
                     ->setLastModified(new Timestamp($domain->getUpdatedAt()))
                     ->setStatus(EventStatus::CONFIRMED())
@@ -172,20 +329,55 @@ class WatchListController extends AbstractController
         ]);
     }
 
+    /**
+     * @throws \Exception
+     */
     #[Route(
-        path: '/api/watchlists',
-        name: 'watchlist_get_all_mine',
+        path: '/api/tracked',
+        name: 'watchlist_get_tracked_domains',
         defaults: [
             '_api_resource_class' => WatchList::class,
-            '_api_operation_name' => 'get_all_mine',
-        ],
-        methods: ['GET']
+            '_api_operation_name' => 'get_tracked_domains',
+        ]
     )]
-    public function getWatchLists(): Collection
+    public function getTrackedDomains(): array
     {
         /** @var User $user */
         $user = $this->getUser();
 
-        return $user->getWatchLists();
+        $domains = [];
+        /** @var WatchList $watchList */
+        foreach ($user->getWatchLists()->getIterator() as $watchList) {
+            /** @var Domain $domain */
+            foreach ($watchList->getDomains()->getIterator() as $domain) {
+                /** @var DomainEvent|null $exp */
+                $exp = $domain->getEvents()->findFirst(fn (int $key, DomainEvent $e) => !$e->getDeleted() && 'expiration' === $e->getAction());
+
+                if (!$domain->getDeleted()
+                    && null !== $exp && $exp->getDate() > new \DateTimeImmutable()
+                    && count(array_filter($domain->getEvents()->toArray(), fn (DomainEvent $e) => !$e->getDeleted() && 'expiration' === $e->getAction())) > 0
+                    && !in_array($domain, $domains)) {
+                    $domains[] = $domain;
+                }
+            }
+        }
+
+        usort($domains, function (Domain $d1, Domain $d2) {
+            $IMPORTANT_STATUS = ['pending delete', 'redemption period', 'auto renew period'];
+
+            /** @var \DateTimeImmutable $exp1 */
+            $exp1 = $d1->getEvents()->findFirst(fn (int $key, DomainEvent $e) => !$e->getDeleted() && 'expiration' === $e->getAction())->getDate();
+            /** @var \DateTimeImmutable $exp2 */
+            $exp2 = $d2->getEvents()->findFirst(fn (int $key, DomainEvent $e) => !$e->getDeleted() && 'expiration' === $e->getAction())->getDate();
+            $impStatus1 = count(array_intersect($IMPORTANT_STATUS, $d1->getStatus())) > 0;
+            $impStatus2 = count(array_intersect($IMPORTANT_STATUS, $d2->getStatus())) > 0;
+
+            return $impStatus1 && !$impStatus2 ? -1 : (
+                !$impStatus1 && $impStatus2 ? 2 :
+                    $exp1 <=> $exp2
+            );
+        });
+
+        return $domains;
     }
 }