Cavemanon/piratepoet
7
Fork 0
Code Pull Requests Actions Releases 16 Activity

Use Doctrine in Newsletter::setStatus()

Browse Source 
[MAILPOET-2946]
This commit is contained in:
Jan Lysý
2020-10-19 19:01:18 +02:00
committed by Veljko V
parent 4843c124ef
commit d5aac0778d
4 changed files with 142 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
lib/API/JSON/v1/Newsletters.php
View File

@ -10,11 +10,12 @@ use MailPoet\Config\AccessControl;
use MailPoet\Cron\CronHelper; use MailPoet\Cron\CronHelper;
use MailPoet\DI\ContainerWrapper; use MailPoet\DI\ContainerWrapper;
use MailPoet\Entities\NewsletterEntity; use MailPoet\Entities\NewsletterEntity;
use MailPoet\Entities\NewsletterOptionFieldEntity;
use MailPoet\Entities\SendingQueueEntity;
use MailPoet\Listing; use MailPoet\Listing;
use MailPoet\Models\Newsletter; use MailPoet\Models\Newsletter;
use MailPoet\Models\NewsletterOption; use MailPoet\Models\NewsletterOption;
use MailPoet\Models\NewsletterOptionField; use MailPoet\Models\NewsletterOptionField;
use MailPoet\Models\SendingQueue;
use MailPoet\Newsletter\Listing\NewsletterListingRepository; use MailPoet\Newsletter\Listing\NewsletterListingRepository;
use MailPoet\Newsletter\NewsletterSaveController; use MailPoet\Newsletter\NewsletterSaveController;
use MailPoet\Newsletter\NewslettersRepository; use MailPoet\Newsletter\NewslettersRepository;
@ -156,47 +157,52 @@ class Newsletters extends APIEndpoint {
]); ]);
} }
if ($status === Newsletter::STATUS_ACTIVE && $this->subscribersFeature->check()) { if ($status === NewsletterEntity::STATUS_ACTIVE && $this->subscribersFeature->check()) {
return $this->errorResponse([ return $this->errorResponse([
APIError::FORBIDDEN => __('Subscribers limit reached.', 'mailpoet'), APIError::FORBIDDEN => __('Subscribers limit reached.', 'mailpoet'),
], [], Response::STATUS_FORBIDDEN); ], [], Response::STATUS_FORBIDDEN);
} }
$id = (isset($data['id'])) ? (int)$data['id'] : false; $newsletter = $this->getNewsletter($data);
$newsletter = Newsletter::findOneWithOptions($id); $this->newslettersRepository->prefetchOptions([$newsletter]);
if ($newsletter === false) { if ($newsletter === null) {
return $this->errorResponse([ return $this->errorResponse([
APIError::NOT_FOUND => __('This email does not exist.', 'mailpoet'), APIError::NOT_FOUND => __('This email does not exist.', 'mailpoet'),
]); ]);
} }
$newsletter->setStatus($status); $newsletter->setStatus($status);
$errors = $newsletter->getErrors();
if (!empty($errors)) {
return $this->errorResponse($errors);
}
// if there are past due notifications, reschedule them for the next send date // if there are past due notifications, reschedule them for the next send date
if ($newsletter->type === Newsletter::TYPE_NOTIFICATION && $status === Newsletter::STATUS_ACTIVE) { if ($newsletter->getType() === NewsletterEntity::TYPE_NOTIFICATION && $status === NewsletterEntity::STATUS_ACTIVE) {
$nextRunDate = Scheduler::getNextRunDate($newsletter->schedule); $scheduleOption = $newsletter->getOption(NewsletterOptionFieldEntity::NAME_SCHEDULE);
$queue = $newsletter->queue()->findOne(); if ($scheduleOption === null) {
if ($queue) { return $this->errorResponse([
$queue->task() APIError::BAD_REQUEST => __('This email has incorrect state.', 'mailpoet'),
->whereLte('scheduled_at', Carbon::createFromTimestamp($this->wp->currentTime('timestamp'))) ]);
->where('status', SendingQueue::STATUS_SCHEDULED) }
->findResultSet() $nextRunDate = Scheduler::getNextRunDate($scheduleOption->getValue());
->set('scheduled_at', $nextRunDate) $queues = $newsletter->getQueues();
->save(); foreach ($queues as $queue) {
$task = $queue->getTask();
if (
$task &&
$task->getScheduledAt() <= Carbon::createFromTimestamp($this->wp->currentTime('timestamp')) &&
$task->getStatus() === SendingQueueEntity::STATUS_SCHEDULED
) {
$task->setScheduledAt(Carbon::createFromFormat('Y-m-d H:i:s', $nextRunDate));
}
} }
$this->postNotificationScheduler->createPostNotificationSendingTask($newsletter); $this->postNotificationScheduler->createPostNotificationSendingTask($newsletter);
} }
$newsletter = Newsletter::findOne($newsletter->id); $this->newslettersRepository->flush();
if(!$newsletter instanceof Newsletter) return $this->errorResponse(); if (!$newsletter instanceof NewsletterEntity) {
return $this->errorResponse();
}
return $this->successResponse( return $this->successResponse(
$newsletter->asArray() $this->newslettersResponseBuilder->build($newsletter)
); );
} }
@ -415,7 +421,10 @@ class Newsletters extends APIEndpoint {
$data['type'] === Newsletter::TYPE_NOTIFICATION $data['type'] === Newsletter::TYPE_NOTIFICATION
) { ) {
$newsletter = Newsletter::filter('filterWithOptions', $data['type'])->findOne($newsletter->id); $newsletter = Newsletter::filter('filterWithOptions', $data['type'])->findOne($newsletter->id);
$this->postNotificationScheduler->processPostNotificationSchedule($newsletter); assert($newsletter instanceof Newsletter);
$newsletterEntity = $this->newslettersRepository->findOneById($newsletter->id);
assert($newsletterEntity instanceof NewsletterEntity);
$this->postNotificationScheduler->processPostNotificationSchedule($newsletterEntity);
} }
$newsletter = Newsletter::findOne($newsletter->id); $newsletter = Newsletter::findOne($newsletter->id);

2
lib/Newsletter/NewsletterSaveController.php
View File

@ -251,7 +251,7 @@ class NewsletterSaveController {
} }
// generate the new schedule from options and get the new "next run" date // generate the new schedule from options and get the new "next run" date
$schedule = $this->postNotificationScheduler->processPostNotificationSchedule($newsletterModel); $schedule = $this->postNotificationScheduler->processPostNotificationSchedule($newsletter);
$nextRunDateString = Scheduler::getNextRunDate($schedule); $nextRunDateString = Scheduler::getNextRunDate($schedule);
$nextRunDate = $nextRunDateString ? Carbon::createFromFormat('Y-m-d H:i:s', $nextRunDateString) : null; $nextRunDate = $nextRunDateString ? Carbon::createFromFormat('Y-m-d H:i:s', $nextRunDateString) : null;
if ($nextRunDate === false) { if ($nextRunDate === false) {

19
lib/Newsletter/NewslettersRepository.php
View File

@ -322,6 +322,25 @@ class NewslettersRepository extends Repository {
return count($ids); return count($ids);
} }
public function existsNotificationHistory(NewsletterEntity $newsletter): bool {
$result = $this->entityManager->createQueryBuilder()
->select('n')
->from(NewsletterEntity::class, 'n')
->join('n.queues', 'q')
->join('q.task', 't')
->where('n.parent = :parent')
->andWhere('n.type = :type')
->andWhere('n.status = :status')
->andWhere('t.status != :taskStatus')
->setParameter('parent', $newsletter)
->setParameter('type', NewsletterEntity::TYPE_NOTIFICATION_HISTORY)
->setParameter('status', NewsletterEntity::STATUS_SENDING)
->setParameter('taskStatus', ScheduledTaskEntity::STATUS_PAUSED)
->setMaxResults(1)
->getQuery()->execute();
return count($result) > 0;
}
public function prefetchOptions(array $newsletters) { public function prefetchOptions(array $newsletters) {
$this->entityManager->createQueryBuilder() $this->entityManager->createQueryBuilder()
->select('PARTIAL n.{id}, o, opf') ->select('PARTIAL n.{id}, o, opf')

149
lib/Newsletter/Scheduler/PostNotificationScheduler.php
View File

@ -2,13 +2,15 @@
namespace MailPoet\Newsletter\Scheduler; namespace MailPoet\Newsletter\Scheduler;
use MailPoet\Entities\NewsletterEntity;
use MailPoet\Entities\NewsletterOptionEntity;
use MailPoet\Entities\NewsletterOptionFieldEntity;
use MailPoet\Logging\LoggerFactory; use MailPoet\Logging\LoggerFactory;
use MailPoet\Models\Newsletter;
use MailPoet\Models\NewsletterOption;
use MailPoet\Models\NewsletterOptionField;
use MailPoet\Models\NewsletterPost;
use MailPoet\Models\ScheduledTask;
use MailPoet\Models\SendingQueue; use MailPoet\Models\SendingQueue;
use MailPoet\Newsletter\NewsletterPostsRepository;
use MailPoet\Newsletter\NewslettersRepository;
use MailPoet\Newsletter\Options\NewsletterOptionFieldsRepository;
use MailPoet\Newsletter\Options\NewsletterOptionsRepository;
use MailPoet\Tasks\Sending as SendingTask; use MailPoet\Tasks\Sending as SendingTask;
use MailPoet\WP\Posts; use MailPoet\WP\Posts;
@ -26,8 +28,29 @@ class PostNotificationScheduler {
/** @var LoggerFactory */ /** @var LoggerFactory */
private $loggerFactory; private $loggerFactory;
public function __construct() { /** @var NewslettersRepository */
private $newslettersRepository;
/** @var NewsletterOptionsRepository */
private $newsletterOptionsRepository;
/** @var NewsletterOptionFieldsRepository */
private $newsletterOptionFieldsRepository;
/** @var NewsletterPostsRepository */
private $newsletterPostsRepository;
public function __construct(
NewslettersRepository $newslettersRepository,
NewsletterOptionsRepository $newsletterOptionsRepository,
NewsletterOptionFieldsRepository $newsletterOptionFieldsRepository,
NewsletterPostsRepository $newsletterPostsRepository
) {
$this->loggerFactory = LoggerFactory::getInstance(); $this->loggerFactory = LoggerFactory::getInstance();
$this->newslettersRepository = $newslettersRepository;
$this->newsletterOptionsRepository = $newsletterOptionsRepository;
$this->newsletterOptionFieldsRepository = $newsletterOptionFieldsRepository;
$this->newsletterPostsRepository = $newsletterPostsRepository;
} }
public function transitionHook($newStatus, $oldStatus, $post) { public function transitionHook($newStatus, $oldStatus, $post) {
@ -51,47 +74,47 @@ class PostNotificationScheduler {
'schedule post notification hook', 'schedule post notification hook',
['post_id' => $postId] ['post_id' => $postId]
); );
$newsletters = Scheduler::getNewsletters(Newsletter::TYPE_NOTIFICATION); $newsletters = $this->newslettersRepository->findActiveByTypes([NewsletterEntity::TYPE_NOTIFICATION]);
if (!count($newsletters)) return false; $this->newslettersRepository->prefetchOptions($newsletters);
if (!count($newsletters)) {
return false;
}
foreach ($newsletters as $newsletter) { foreach ($newsletters as $newsletter) {
$post = NewsletterPost::where('newsletter_id', $newsletter->id) $post = $this->newsletterPostsRepository->findOneBy([
->where('post_id', $postId) 'newsletter' => $newsletter,
->findOne(); 'postId' => $postId,
if ($post === false) { ]);
if ($post === null) {
$this->createPostNotificationSendingTask($newsletter); $this->createPostNotificationSendingTask($newsletter);
} }
} }
} }
public function createPostNotificationSendingTask($newsletter) { public function createPostNotificationSendingTask(NewsletterEntity $newsletter): ?SendingTask {
$existingNotificationHistory = Newsletter::tableAlias('newsletters') $notificationHistoryExists = $this->newslettersRepository->existsNotificationHistory($newsletter);
->where('newsletters.parent_id', $newsletter->id) if ($notificationHistoryExists) {
->where('newsletters.type', Newsletter::TYPE_NOTIFICATION_HISTORY) return null;
->where('newsletters.status', Newsletter::STATUS_SENDING)
->join(
MP_SENDING_QUEUES_TABLE,
'queues.newsletter_id = newsletters.id',
'queues'
)
->join(
MP_SCHEDULED_TASKS_TABLE,
'queues.task_id = tasks.id',
'tasks'
)
->whereNotEqual('tasks.status', ScheduledTask::STATUS_PAUSED)
->findOne();
if ($existingNotificationHistory) {
return;
} }
$nextRunDate = Scheduler::getNextRunDate($newsletter->schedule);
if (!$nextRunDate) return; $scheduleOption = $newsletter->getOption(NewsletterOptionFieldEntity::NAME_SCHEDULE);
if (!$scheduleOption) {
return null;
}
$nextRunDate = Scheduler::getNextRunDate($scheduleOption->getValue());
if (!$nextRunDate) {
return null;
}
// do not schedule duplicate queues for the same time // do not schedule duplicate queues for the same time
$existingQueue = SendingQueue::findTaskByNewsletterId($newsletter->id) $lastQueue = $newsletter->getLatestQueue();
->where('tasks.scheduled_at', $nextRunDate) $task = $lastQueue !== null ? $lastQueue->getTask() : null;
->findOne(); $scheduledAt = $task !== null ? $task->getScheduledAt() : null;
if ($existingQueue) return; if ($scheduledAt && $scheduledAt->format('Y-m-d H:i:s') === $nextRunDate) {
return null;
}
$sendingTask = SendingTask::create(); $sendingTask = SendingTask::create();
$sendingTask->newsletterId = $newsletter->id; $sendingTask->newsletterId = $newsletter->getId();
$sendingTask->status = SendingQueue::STATUS_SCHEDULED; $sendingTask->status = SendingQueue::STATUS_SCHEDULED;
$sendingTask->scheduledAt = $nextRunDate; $sendingTask->scheduledAt = $nextRunDate;
$sendingTask->save(); $sendingTask->save();
@ -102,14 +125,22 @@ class PostNotificationScheduler {
return $sendingTask; return $sendingTask;
} }
public function processPostNotificationSchedule($newsletter) { public function processPostNotificationSchedule(NewsletterEntity $newsletter) {
$intervalType = $newsletter->intervalType; $intervalTypeOption = $newsletter->getOption(NewsletterOptionFieldEntity::NAME_INTERVAL_TYPE);
$hour = (int)$newsletter->timeOfDay / self::SECONDS_IN_HOUR; $intervalType = $intervalTypeOption ? $intervalTypeOption->getValue() : null;
$weekDay = $newsletter->weekDay;
$monthDay = $newsletter->monthDay; $timeOfDayOption = $newsletter->getOption(NewsletterOptionFieldEntity::NAME_TIME_OF_DAY);
$nthWeekDay = ($newsletter->nthWeekDay === self::LAST_WEEKDAY_FORMAT) ? $hour = $timeOfDayOption ? (int)$timeOfDayOption->getValue() / self::SECONDS_IN_HOUR : null;
$newsletter->nthWeekDay :
'#' . $newsletter->nthWeekDay; $weekDayOption = $newsletter->getOption(NewsletterOptionFieldEntity::NAME_WEK_DAY);
$weekDay = $weekDayOption ? $weekDayOption->getValue() : null;
$monthDayOption = $newsletter->getOption(NewsletterOptionFieldEntity::NAME_MONTH_DAY);
$monthDay = $monthDayOption ? $monthDayOption->getValue() : null;
$nthWeekDayOption = $newsletter->getOption(NewsletterOptionFieldEntity::NAME_NTH_WEEK_DAY);
$nthWeekDay = $nthWeekDayOption ? $nthWeekDayOption->getValue() : null;
$nthWeekDay = ($nthWeekDay === self::LAST_WEEKDAY_FORMAT) ? $nthWeekDay : '#' . $nthWeekDay;
switch ($intervalType) { switch ($intervalType) {
case self::INTERVAL_IMMEDIATE: case self::INTERVAL_IMMEDIATE:
case self::INTERVAL_DAILY: case self::INTERVAL_DAILY:
@ -129,22 +160,20 @@ class PostNotificationScheduler {
$schedule = '* * * * *'; $schedule = '* * * * *';
break; break;
} }
$relation = null; $optionField = $this->newsletterOptionFieldsRepository->findOneBy([
$optionField = NewsletterOptionField::where('name', 'schedule')->findOne(); 'name' => NewsletterOptionFieldEntity::NAME_SCHEDULE,
if ($optionField instanceof NewsletterOptionField) { ]);
$relation = NewsletterOption::where('newsletter_id', $newsletter->id) if (!$optionField instanceof NewsletterOptionFieldEntity) {
->where('option_field_id', $optionField->id)
->findOne();
} else {
throw new \Exception('NewsletterOptionField for schedule doesn’t exist.'); throw new \Exception('NewsletterOptionField for schedule doesn’t exist.');
} }
if (!$relation instanceof NewsletterOption) { $scheduleOption = $newsletter->getOption(NewsletterOptionFieldEntity::NAME_SCHEDULE);
$relation = NewsletterOption::create(); if ($scheduleOption === null) {
$relation->newsletterId = $newsletter->id; $scheduleOption = new NewsletterOptionEntity($newsletter, $optionField);
$relation->optionFieldId = (int)$optionField->id; $newsletter->getOptions()->add($scheduleOption);
} }
$relation->value = $schedule; $scheduleOption->setValue($schedule);
$relation->save(); $this->newsletterOptionsRepository->persist($scheduleOption);
return $relation->value; $this->newsletterOptionsRepository->flush();
return $scheduleOption->getValue();
} }
} }