Refactor welcome newsletter scheduler to Doctrine

[MAILPOET-3141]

lib/Entities/NewsletterEntity.php

@@ -387,6 +387,11 @@ class NewsletterEntity {
     return $option ?: null;
   }
 
+  public function getOptionValue(string $name) {
+    $option = $this->getOption($name);
+    return $option ? $option->getValue() : null;
+  }
+
   /**
    * @return SendingQueueEntity[]|ArrayCollection
    */

lib/Newsletter/Scheduler/WelcomeScheduler.php

@@ -2,10 +2,13 @@
 
 namespace MailPoet\Newsletter\Scheduler;
 
+use MailPoet\Entities\NewsletterEntity;
+use MailPoet\Entities\NewsletterOptionFieldEntity;
 use MailPoet\Entities\SegmentEntity;
 use MailPoet\Entities\SubscriberEntity;
-use MailPoet\Models\Newsletter;
 use MailPoet\Models\SendingQueue;
+use MailPoet\Newsletter\NewslettersRepository;
+use MailPoet\Newsletter\Sending\ScheduledTasksRepository;
 use MailPoet\Segments\SegmentsRepository;
 use MailPoet\Subscribers\SubscribersRepository;
 use MailPoet\Tasks\Sending as SendingTask;
@@ -20,21 +23,31 @@ class WelcomeScheduler {
   /** @var SegmentsRepository */
   private $segmentsRepository;
 
+  /** @var NewslettersRepository */
+  private $newslettersRepository;
+
+  /** @var ScheduledTasksRepository */
+  private $scheduledTasksRepository;
+
   public function __construct(
     SubscribersRepository $subscribersRepository,
-    SegmentsRepository $segmentsRepository
+    SegmentsRepository $segmentsRepository,
+    NewslettersRepository $newslettersRepository,
+    ScheduledTasksRepository $scheduledTasksRepository
   ) {
     $this->subscribersRepository = $subscribersRepository;
     $this->segmentsRepository = $segmentsRepository;
+    $this->newslettersRepository = $newslettersRepository;
+    $this->scheduledTasksRepository = $scheduledTasksRepository;
   }
 
   public function scheduleSubscriberWelcomeNotification($subscriberId, $segments) {
-    $newsletters = Scheduler::getNewsletters(Newsletter::TYPE_WELCOME);
+    $newsletters = $this->newslettersRepository->findActiveByTypes([NewsletterEntity::TYPE_WELCOME]);
     if (empty($newsletters)) return false;
     $result = [];
     foreach ($newsletters as $newsletter) {
-      if ($newsletter->event === 'segment' &&
+      if ($newsletter->getOptionValue(NewsletterOptionFieldEntity::NAME_EVENT) === 'segment' &&
-        in_array($newsletter->segment, $segments)
+        in_array($newsletter->getOptionValue(NewsletterOptionFieldEntity::NAME_SEGMENT), $segments)
       ) {
         $sendingTask = $this->createWelcomeNotificationSendingTask($newsletter, $subscriberId);
         if ($sendingTask) {
@@ -50,59 +63,58 @@ class WelcomeScheduler {
     $wpUser,
     $oldUserData = false
   ) {
-    $newsletters = Scheduler::getNewsletters(Newsletter::TYPE_WELCOME);
+    $newsletters = $this->newslettersRepository->findActiveByTypes([NewsletterEntity::TYPE_WELCOME]);
     if (empty($newsletters)) return false;
     foreach ($newsletters as $newsletter) {
-      if ($newsletter->event === 'user') {
+      if ($newsletter->getOptionValue(NewsletterOptionFieldEntity::NAME_EVENT) !== 'user') {
-        if (!empty($oldUserData['roles'])) {
+        continue;
-          // do not schedule welcome newsletter if roles have not changed
+      }
-          $oldRole = $oldUserData['roles'];
+      $newsletterRole = $newsletter->getOptionValue(NewsletterOptionFieldEntity::NAME_ROLE);
-          $newRole = $wpUser['roles'];
+      if (!empty($oldUserData['roles'])) {
-          if ($newsletter->role === self::WORDPRESS_ALL_ROLES ||
+        // do not schedule welcome newsletter if roles have not changed
-            !array_diff($oldRole, $newRole)
+        $oldRole = $oldUserData['roles'];
-          ) {
+        $newRole = $wpUser['roles'];
-            continue;
+        if ($newsletterRole === self::WORDPRESS_ALL_ROLES ||
-          }
+          !array_diff($oldRole, $newRole)
-        }
-        if ($newsletter->role === self::WORDPRESS_ALL_ROLES ||
-          in_array($newsletter->role, $wpUser['roles'])
         ) {
-          $this->createWelcomeNotificationSendingTask($newsletter, $subscriberId);
+          continue;
         }
       }
+      if ($newsletterRole === self::WORDPRESS_ALL_ROLES ||
+        in_array($newsletterRole, $wpUser['roles'])
+      ) {
+        $this->createWelcomeNotificationSendingTask($newsletter, $subscriberId);
+      }
     }
   }
 
-  public function createWelcomeNotificationSendingTask($newsletter, $subscriberId) {
+  public function createWelcomeNotificationSendingTask(NewsletterEntity $newsletter, $subscriberId) {
     $subscriber = $this->subscribersRepository->findOneById($subscriberId);
     if (!($subscriber instanceof SubscriberEntity) || $subscriber->getDeletedAt() !== null) {
       return;
     }
-    if ($newsletter->event === 'segment') {
+    if ($newsletter->getOptionValue(NewsletterOptionFieldEntity::NAME_EVENT) === 'segment') {
-      $segment = $this->segmentsRepository->findOneById((int)$newsletter->segment);
+      $segment = $this->segmentsRepository->findOneById((int)$newsletter->getOptionValue(NewsletterOptionFieldEntity::NAME_SEGMENT));
       if ((!$segment instanceof SegmentEntity) || $segment->getDeletedAt() !== null) {
         return;
       }
     }
-    if ($newsletter->event === 'user') {
+    if ($newsletter->getOptionValue(NewsletterOptionFieldEntity::NAME_EVENT) === 'user') {
       $segment = $this->segmentsRepository->getWPUsersSegment();
       if ((!$segment instanceof SegmentEntity) || $segment->getDeletedAt() !== null) {
         return;
       }
     }
-    $previouslyScheduledNotification = SendingQueue::joinWithSubscribers()
+    $previouslyScheduledNotification = $this->scheduledTasksRepository->findByNewsletterAndSubscriberId($newsletter, $subscriberId);
-      ->where('queues.newsletter_id', $newsletter->id)
-      ->where('subscribers.subscriber_id', $subscriberId)
-      ->findOne();
     if (!empty($previouslyScheduledNotification)) return;
     $sendingTask = SendingTask::create();
-    $sendingTask->newsletterId = $newsletter->id;
+    $sendingTask->newsletterId = $newsletter->getId();
     $sendingTask->setSubscribers([$subscriberId]);
     $sendingTask->status = SendingQueue::STATUS_SCHEDULED;
     $sendingTask->priority = SendingQueue::PRIORITY_HIGH;
     $sendingTask->scheduledAt = Scheduler::getScheduledTimeWithDelay(
-      $newsletter->afterTimeType,
+      $newsletter->getOptionValue(NewsletterOptionFieldEntity::NAME_AFTER_TIME_TYPE),
-      $newsletter->afterTimeNumber
+      $newsletter->getOptionValue(NewsletterOptionFieldEntity::NAME_AFTER_TIME_NUMBER)
     );
     return $sendingTask->save();
   }

lib/Newsletter/Sending/ScheduledTasksRepository.php

@@ -5,6 +5,7 @@ namespace MailPoet\Newsletter\Sending;
 use MailPoet\Doctrine\Repository;
 use MailPoet\Entities\NewsletterEntity;
 use MailPoet\Entities\ScheduledTaskEntity;
+use MailPoet\Entities\ScheduledTaskSubscriberEntity;
 use MailPoet\Entities\SendingQueueEntity;
 use MailPoetVendor\Doctrine\ORM\Query\Expr\Join;
 
@@ -28,6 +29,23 @@ class ScheduledTasksRepository extends Repository {
       ->getResult();
   }
 
+  /**
+   * @param NewsletterEntity $newsletter
+   * @return ScheduledTaskEntity[]
+   */
+  public function findByNewsletterAndSubscriberId(NewsletterEntity $newsletter, int $subscriberId): array {
+    return $this->doctrineRepository->createQueryBuilder('st')
+      ->select('st')
+      ->join(SendingQueueEntity::class, 'sq', Join::WITH, 'st = sq.task')
+      ->join(ScheduledTaskSubscriberEntity::class, 'sts', Join::WITH, 'st = sts.task')
+      ->andWhere('sq.newsletter = :newsletter')
+      ->andWhere('sts.subscriber = :subscriber')
+      ->setParameter('newsletter', $newsletter)
+      ->setParameter('subscriber', $subscriberId)
+      ->getQuery()
+      ->getResult();
+  }
+
   protected function getEntityClassName() {
     return ScheduledTaskEntity::class;
   }

tests/integration/Newsletter/Scheduler/WelcomeTest.php

@@ -2,6 +2,9 @@
 
 namespace MailPoet\Newsletter\Scheduler;
 
+use MailPoet\Entities\NewsletterEntity;
+use MailPoet\Entities\NewsletterOptionEntity;
+use MailPoet\Entities\NewsletterOptionFieldEntity;
 use MailPoet\Entities\SegmentEntity;
 use MailPoet\Entities\SubscriberEntity;
 use MailPoet\Models\Newsletter;
@@ -32,25 +35,29 @@ class WelcomeTest extends \MailPoetTest {
   /** @var SegmentEntity */
   private $wpSegment;
 
+  /** @var NewsletterEntity */
+  private $newsletter;
+
   public function _before() {
     parent::_before();
     $this->welcomeScheduler = $this->diContainer->get(WelcomeScheduler::class);
     $this->subscriber = $this->createSubscriber('welcome_test_1@example.com');
     $this->segment = $this->createSegment('welcome_segment');
     $this->wpSegment = $this->createSegment('Wordpress', SegmentEntity::TYPE_WP_USERS);
+    $this->newsletter = $this->createWelcomeNewsletter();
   }
 
   public function testItDoesNotCreateDuplicateWelcomeNotificationSendingTasks() {
-    $newsletter = (object)[
+    $newsletter = $this->configureNewsletterWithOptions($this->newsletter, [
-      'id' => 1,
       'afterTimeNumber' => 2,
       'afterTimeType' => 'hours',
       'event' => 'segment',
       'segment' => $this->segment->getId(),
-    ];
+    ]);
+
     $existingSubscriber = $this->subscriber->getId();
     $existingQueue = SendingTask::create();
-    $existingQueue->newsletterId = $newsletter->id;
+    $existingQueue->newsletterId = $newsletter->getId();
     $existingQueue->setSubscribers([$existingSubscriber]);
     $existingQueue->save();
 
@@ -65,15 +72,14 @@ class WelcomeTest extends \MailPoetTest {
   }
 
   public function testItCreatesWelcomeNotificationSendingTaskScheduledToSendInHours() {
-    $newsletter = (object)[
+    // queue is scheduled delivery in 2 hours
-      'id' => 1,
+    $newsletter = $this->configureNewsletterWithOptions($this->newsletter, [
       'afterTimeNumber' => 2,
+      'afterTimeType' => 'hours',
       'event' => 'segment',
       'segment' => $this->segment->getId(),
-    ];
+    ]);
 
-    // queue is scheduled delivery in 2 hours
-    $newsletter->afterTimeType = 'hours';
     $this->welcomeScheduler->createWelcomeNotificationSendingTask($newsletter, $this->subscriber->getId());
     $queue = SendingQueue::findTaskByNewsletterId(1)
       ->findOne();
@@ -86,15 +92,14 @@ class WelcomeTest extends \MailPoetTest {
   }
 
   public function testItCreatesWelcomeNotificationSendingTaskScheduledToSendInDays() {
-    $newsletter = (object)[
+    // queue is scheduled for delivery in 2 days
-      'id' => 1,
+    $newsletter = $this->configureNewsletterWithOptions($this->newsletter, [
       'afterTimeNumber' => 2,
+      'afterTimeType' => 'days',
       'event' => 'segment',
       'segment' => $this->segment->getId(),
-    ];
+    ]);
 
-    // queue is scheduled for delivery in 2 days
-    $newsletter->afterTimeType = 'days';
     $this->welcomeScheduler->createWelcomeNotificationSendingTask($newsletter, $this->subscriber->getId());
     $currentTime = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
     Carbon::setTestNow($currentTime); // mock carbon to return current time
@@ -107,15 +112,14 @@ class WelcomeTest extends \MailPoetTest {
   }
 
   public function testItCreatesWelcomeNotificationSendingTaskScheduledToSendInWeeks() {
-    $newsletter = (object)[
+    // queue is scheduled for delivery in 2 weeks
-      'id' => 1,
+    $newsletter = $this->configureNewsletterWithOptions($this->newsletter, [
       'afterTimeNumber' => 2,
+      'afterTimeType' => 'weeks',
       'event' => 'segment',
       'segment' => $this->segment->getId(),
-    ];
+    ]);
 
-    // queue is scheduled for delivery in 2 weeks
-    $newsletter->afterTimeType = 'weeks';
     $this->welcomeScheduler->createWelcomeNotificationSendingTask($newsletter, $this->subscriber->getId());
     $currentTime = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
     Carbon::setTestNow($currentTime); // mock carbon to return current time
@@ -128,15 +132,14 @@ class WelcomeTest extends \MailPoetTest {
   }
 
   public function testItCreatesWelcomeNotificationSendingTaskScheduledToSendImmediately() {
-    $newsletter = (object)[
+    // queue is scheduled for immediate delivery
-      'id' => 1,
+    $newsletter = $this->configureNewsletterWithOptions($this->newsletter, [
       'afterTimeNumber' => 2,
+      'afterTimeType' => null,
       'event' => 'segment',
       'segment' => $this->segment->getId(),
-    ];
+    ]);
 
-    // queue is scheduled for immediate delivery
-    $newsletter->afterTimeType = null;
     $this->welcomeScheduler->createWelcomeNotificationSendingTask($newsletter, $this->subscriber->getId());
     $currentTime = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
     Carbon::setTestNow($currentTime); // mock carbon to return current time
@@ -428,6 +431,37 @@ class WelcomeTest extends \MailPoetTest {
     }
   }
 
+  private function createWelcomeNewsletter($status = NewsletterEntity::STATUS_ACTIVE): NewsletterEntity {
+    $newsletter = new NewsletterEntity();
+    $newsletter->setSubject('Welcome Newsletter');
+    $newsletter->setType(NewsletterEntity::TYPE_WELCOME);
+    $newsletter->setStatus($status);
+    $this->entityManager->persist($newsletter);
+    $this->entityManager->flush();
+    return $newsletter;
+  }
+
+  private function configureNewsletterWithOptions(NewsletterEntity $newsletter, array $options) {
+    foreach ($options as $optionFieldName => $optionValue) {
+      $optionField = $this->entityManager->getRepository(NewsletterOptionFieldEntity::class)->findOneBy([
+        'name' => $optionFieldName,
+        'newsletterType' => NewsletterEntity::TYPE_WELCOME,
+      ]);
+      if (!$optionField instanceof NewsletterOptionFieldEntity) {
+        $optionField = new NewsletterOptionFieldEntity();
+        $optionField->setNewsletterType(NewsletterEntity::TYPE_WELCOME);
+        $optionField->setName($optionFieldName);
+        $this->entityManager->persist($optionField);
+      }
+      $option = new NewsletterOptionEntity($newsletter, $optionField);
+      $option->setValue($optionValue);
+      $this->entityManager->persist($option);
+      $newsletter->getOptions()->add($option);
+    }
+    $this->entityManager->flush();
+    return $newsletter;
+  }
+
   private function createSubscriber($email): SubscriberEntity {
     $subscriber = new SubscriberEntity();
     $subscriber->setStatus(SubscriberEntity::STATUS_SUBSCRIBED);