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

Add public keyword to methods

Browse Source 
[MAILPOET-2413]
This commit is contained in:
Amine Ben hammou
2019-12-26 12:56:49 +01:00
committed by wxa
parent ec409042d5
commit 43df66d162
823 changed files with 4440 additions and 4440 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
lib/Cron/CronHelper.php
View File

@ -29,18 +29,18 @@ class CronHelper {
$this->wp = $wp;
}
function getDaemonExecutionLimit() {
public function getDaemonExecutionLimit() {
$limit = $this->wp->applyFilters('mailpoet_cron_get_execution_limit', self::DAEMON_EXECUTION_LIMIT);
return $limit;
}
function getDaemonExecutionTimeout() {
public function getDaemonExecutionTimeout() {
$limit = $this->getDaemonExecutionLimit();
$timeout = $limit * 1.75;
return $this->wp->applyFilters('mailpoet_cron_get_execution_timeout', $timeout);
}
function createDaemon($token) {
public function createDaemon($token) {
$daemon = [
'token' => $token,
'status' => self::DAEMON_STATUS_ACTIVE,
@ -54,15 +54,15 @@ class CronHelper {
return $daemon;
}
function restartDaemon($token) {
public function restartDaemon($token) {
return $this->createDaemon($token);
}
function getDaemon() {
public function getDaemon() {
return $this->settings->fetch(self::DAEMON_SETTING);
}
function saveDaemonLastError($error) {
public function saveDaemonLastError($error) {
$daemon = $this->getDaemon();
if ($daemon) {
$daemon['last_error'] = $error;
@ -71,7 +71,7 @@ class CronHelper {
}
}
function saveDaemonRunCompleted($run_completed_at) {
public function saveDaemonRunCompleted($run_completed_at) {
$daemon = $this->getDaemon();
if ($daemon) {
$daemon['run_completed_at'] = $run_completed_at;
@ -79,7 +79,7 @@ class CronHelper {
}
}
function saveDaemon($daemon) {
public function saveDaemon($daemon) {
$daemon['updated_at'] = time();
$this->settings->set(
self::DAEMON_SETTING,
@ -87,7 +87,7 @@ class CronHelper {
);
}
function deactivateDaemon($daemon) {
public function deactivateDaemon($daemon) {
$daemon['status'] = self::DAEMON_STATUS_INACTIVE;
$this->settings->set(
self::DAEMON_SETTING,
@ -95,11 +95,11 @@ class CronHelper {
);
}
function createToken() {
public function createToken() {
return Security::generateRandomString();
}
function pingDaemon() {
public function pingDaemon() {
$url = $this->getCronUrl(
CronDaemonEndpoint::ACTION_PING_RESPONSE
);
@ -112,11 +112,11 @@ class CronHelper {
return $response;
}
function validatePingResponse($response) {
public function validatePingResponse($response) {
return $response === DaemonHttpRunner::PING_SUCCESS_RESPONSE;
}
function accessDaemon($token) {
public function accessDaemon($token) {
$data = ['token' => $token];
$url = $this->getCronUrl(
CronDaemonEndpoint::ACTION_RUN,
@ -135,7 +135,7 @@ class CronHelper {
/**
* @return boolean|null
*/
function isDaemonAccessible() {
public function isDaemonAccessible() {
$daemon = $this->getDaemon();
if (!$daemon || !isset($daemon['run_accessed_at']) || $daemon['run_accessed_at'] === null) {
return null;
@ -152,7 +152,7 @@ class CronHelper {
return null;
}
function queryCronUrl($url) {
public function queryCronUrl($url) {
$args = $this->wp->applyFilters(
'mailpoet_cron_request_args',
[
@ -165,7 +165,7 @@ class CronHelper {
return $this->wp->wpRemotePost($url, $args);
}
function getCronUrl($action, $data = false) {
public function getCronUrl($action, $data = false) {
$url = Router::buildRequest(
CronDaemonEndpoint::ENDPOINT,
$action,
@ -177,7 +177,7 @@ class CronHelper {
$custom_cron_url;
}
function getSiteUrl($site_url = false) {
public function getSiteUrl($site_url = false) {
// additional check for some sites running inside a virtual machine or behind
// proxy where there could be different ports (e.g., host:8080 => guest:80)
$site_url = ($site_url) ? $site_url : WPFunctions::get()->homeUrl();
@ -200,7 +200,7 @@ class CronHelper {
throw new \Exception(__('Site URL is unreachable.', 'mailpoet'));
}
function enforceExecutionLimit($timer) {
public function enforceExecutionLimit($timer) {
$elapsed_time = microtime(true) - $timer;
if ($elapsed_time >= $this->getDaemonExecutionLimit()) {
throw new \Exception(__('Maximum execution time has been reached.', 'mailpoet'), self::DAEMON_EXECUTION_LIMIT_REACHED);

4
lib/Cron/CronTrigger.php
View File

@ -30,7 +30,7 @@ class CronTrigger {
/** @var SettingsController */
private $settings;
function __construct(
public function __construct(
MailPoet $mailpoet_trigger,
WordPress $wordpress_trigger,
SettingsController $settings
@ -40,7 +40,7 @@ class CronTrigger {
$this->settings = $settings;
}
function init() {
public function init() {
$current_method = $this->settings->get(self::SETTING_NAME . '.method');
try {
if ($current_method === self::METHOD_MAILPOET) {

16
lib/Cron/CronWorkerInterface.php
View File

@ -6,33 +6,33 @@ use MailPoet\Models\ScheduledTask;
interface CronWorkerInterface {
/** @return string */
function getTaskType();
public function getTaskType();
/** @return bool */
function scheduleAutomatically();
public function scheduleAutomatically();
/** @return bool */
function supportsMultipleInstances();
public function supportsMultipleInstances();
/** @return bool */
function checkProcessingRequirements();
public function checkProcessingRequirements();
function init();
public function init();
/**
* @param ScheduledTask $task
* @param float $timer
* @return bool
*/
function prepareTaskStrategy(ScheduledTask $task, $timer);
public function prepareTaskStrategy(ScheduledTask $task, $timer);
/**
* @param ScheduledTask $task
* @param float $timer
* @return bool
*/
function processTaskStrategy(ScheduledTask $task, $timer);
public function processTaskStrategy(ScheduledTask $task, $timer);
/** @return \DateTimeInterface */
function getNextRunDate();
public function getNextRunDate();
}

4
lib/Cron/CronWorkerRunner.php
View File

@ -23,14 +23,14 @@ class CronWorkerRunner {
/** @var WPFunctions */
private $wp;
function __construct(CronHelper $cron_helper, CronWorkerScheduler $cron_worker_scheduler, WPFunctions $wp) {
public function __construct(CronHelper $cron_helper, CronWorkerScheduler $cron_worker_scheduler, WPFunctions $wp) {
$this->timer = microtime(true);
$this->cron_helper = $cron_helper;
$this->cron_worker_scheduler = $cron_worker_scheduler;
$this->wp = $wp;
}
function run(CronWorkerInterface $worker) {
public function run(CronWorkerInterface $worker) {
// abort if execution limit is reached
$this->cron_helper->enforceExecutionLimit($this->timer);
$due_tasks = $this->getDueTasks($worker);

6
lib/Cron/CronWorkerScheduler.php
View File

@ -10,11 +10,11 @@ class CronWorkerScheduler {
/** @var WPFunctions */
private $wp;
function __construct(WPFunctions $wp) {
public function __construct(WPFunctions $wp) {
$this->wp = $wp;
}
function schedule($task_type, $next_run_date) {
public function schedule($task_type, $next_run_date) {
$already_scheduled = ScheduledTask::where('type', $task_type)
->whereNull('deleted_at')
->where('status', ScheduledTask::STATUS_SCHEDULED)
@ -31,7 +31,7 @@ class CronWorkerScheduler {
return $task;
}
function reschedule(ScheduledTask $task, $timeout) {
public function reschedule(ScheduledTask $task, $timeout) {
$scheduled_at = Carbon::createFromTimestamp($this->wp->currentTime('timestamp'));
$task->scheduled_at = $scheduled_at->addMinutes($timeout);
$task->setExpr('updated_at', 'NOW()');

4
lib/Cron/Daemon.php
View File

@ -16,7 +16,7 @@ class Daemon {
/** @var WorkersFactory */
private $workers_factory;
function __construct(
public function __construct(
CronHelper $cron_helper,
CronWorkerRunner $cron_worker_runner,
WorkersFactory $workers_factory
@ -27,7 +27,7 @@ class Daemon {
$this->cron_helper = $cron_helper;
}
function run($settings_daemon_data) {
public function run($settings_daemon_data) {
$settings_daemon_data['run_started_at'] = time();
$this->cron_helper->saveDaemon($settings_daemon_data);

20
lib/Cron/DaemonHttpRunner.php
View File

@ -26,7 +26,7 @@ class DaemonHttpRunner {
/** @var WordPress */
private $wordpress_trigger;
function __construct(Daemon $daemon = null, CronHelper $cron_helper, SettingsController $settings, WordPress $wordpress_trigger) {
public function __construct(Daemon $daemon = null, CronHelper $cron_helper, SettingsController $settings, WordPress $wordpress_trigger) {
$this->cron_helper = $cron_helper;
$this->settings_daemon_data = $this->cron_helper->getDaemon();
$this->token = $this->cron_helper->createToken();
@ -36,7 +36,7 @@ class DaemonHttpRunner {
$this->wordpress_trigger = $wordpress_trigger;
}
function ping() {
public function ping() {
// if Tracy enabled & called by 'MailPoet Cron' user agent, disable Tracy Bar
// (happens in CronHelperTest because it's not a real integration test - calls other WP instance)
$user_agent = isset($_SERVER['HTTP_USER_AGENT']) ? $_SERVER['HTTP_USER_AGENT'] : null;
@ -47,7 +47,7 @@ class DaemonHttpRunner {
$this->terminateRequest(self::PING_SUCCESS_RESPONSE);
}
function run($request_data) {
public function run($request_data) {
ignore_user_abort(true);
if (strpos(@ini_get('disable_functions'), 'set_time_limit') === false) {
set_time_limit(0);
@ -94,33 +94,33 @@ class DaemonHttpRunner {
return $this->callSelf();
}
function pauseExecution($pause_time) {
public function pauseExecution($pause_time) {
return sleep($pause_time);
}
function callSelf() {
public function callSelf() {
$this->cron_helper->accessDaemon($this->token);
$this->terminateRequest();
}
function abortWithError($message) {
public function abortWithError($message) {
WPFunctions::get()->statusHeader(404, $message);
exit;
}
function terminateRequest($message = false) {
public function terminateRequest($message = false) {
die($message);
}
function isCronTriggerMethodWordPress() {
public function isCronTriggerMethodWordPress() {
return $this->settings->get(CronTrigger::SETTING_NAME . '.method') === CronTrigger::METHOD_WORDPRESS;
}
function checkWPTriggerExecutionRequirements() {
public function checkWPTriggerExecutionRequirements() {
return $this->wordpress_trigger->checkExecutionRequirements();
}
function stopCron() {
public function stopCron() {
return $this->wordpress_trigger->stop();
}

10
lib/Cron/Supervisor.php
View File

@ -9,16 +9,16 @@ class Supervisor {
/** @var CronHelper */
private $cron_helper;
function __construct(CronHelper $cron_helper) {
public function __construct(CronHelper $cron_helper) {
$this->cron_helper = $cron_helper;
}
function init() {
public function init() {
$this->token = $this->cron_helper->createToken();
$this->daemon = $this->getDaemon();
}
function checkDaemon() {
public function checkDaemon() {
$daemon = $this->daemon;
$execution_timeout_exceeded =
(time() - (int)$daemon['updated_at']) >= $this->cron_helper->getDaemonExecutionTimeout();
@ -31,13 +31,13 @@ class Supervisor {
return $daemon;
}
function runDaemon() {
public function runDaemon() {
$this->cron_helper->accessDaemon($this->token);
$daemon = $this->cron_helper->getDaemon();
return $daemon;
}
function getDaemon() {
public function getDaemon() {
$daemon = $this->cron_helper->getDaemon();
if (!$daemon) {
$this->cron_helper->createDaemon($this->token);

4
lib/Cron/Triggers/MailPoet.php
View File

@ -8,11 +8,11 @@ class MailPoet {
/** @var Supervisor */
private $supervisor;
function __construct(Supervisor $supervisor) {
public function __construct(Supervisor $supervisor) {
$this->supervisor = $supervisor;
}
function run() {
public function run() {
$this->supervisor->init();
return $this->supervisor->checkDaemon();
}

10
lib/Cron/Triggers/WordPress.php
View File

@ -45,7 +45,7 @@ class WordPress {
/** @var WPFunctions */
private $wp;
function __construct(
public function __construct(
CronHelper $cron_helper,
MailPoet $mailpoet_trigger,
SettingsController $settings,
@ -57,7 +57,7 @@ class WordPress {
$this->cron_helper = $cron_helper;
}
function run() {
public function run() {
if (!$this->checkRunInterval()) {
return false;
}
@ -77,12 +77,12 @@ class WordPress {
return false;
}
static function resetRunInterval() {
public static function resetRunInterval() {
$settings = SettingsController::getInstance();
$settings->set(self::LAST_RUN_AT_SETTING, 0);
}
function checkExecutionRequirements() {
public function checkExecutionRequirements() {
$this->loadTasksCounts();
// migration
@ -231,7 +231,7 @@ class WordPress {
);
}
function stop() {
public function stop() {
$cron_daemon = $this->cron_helper->getDaemon();
if ($cron_daemon) {
$this->cron_helper->deactivateDaemon($cron_daemon);

6
lib/Cron/Workers/AuthorizedSendingEmailsCheck.php
View File

@ -13,16 +13,16 @@ class AuthorizedSendingEmailsCheck extends SimpleWorker {
/** @var AuthorizedEmailsController */
private $authorized_emails_controller;
function __construct(AuthorizedEmailsController $authorized_emails_controller) {
public function __construct(AuthorizedEmailsController $authorized_emails_controller) {
$this->authorized_emails_controller = $authorized_emails_controller;
parent::__construct();
}
function checkProcessingRequirements() {
public function checkProcessingRequirements() {
return Bridge::isMPSendingServiceEnabled();
}
function processTaskStrategy(ScheduledTask $task, $timer) {
public function processTaskStrategy(ScheduledTask $task, $timer) {
$this->authorized_emails_controller->checkAuthorizedEmailAddresses();
return true;
}

8
lib/Cron/Workers/Beamer.php
View File

@ -18,17 +18,17 @@ class Beamer extends SimpleWorker {
/** @var WPFunctions */
private $wp;
function __construct(SettingsController $settings, WPFunctions $wp) {
public function __construct(SettingsController $settings, WPFunctions $wp) {
parent::__construct();
$this->settings = $settings;
$this->wp = $wp;
}
function processTaskStrategy(ScheduledTask $task, $timer) {
public function processTaskStrategy(ScheduledTask $task, $timer) {
return $this->setLastAnnouncementDate();
}
function setLastAnnouncementDate() {
public function setLastAnnouncementDate() {
$response = $this->wp->wpRemoteGet(self::API_URL . '/posts?published=true&maxResults=1', [
'headers' => [
'Beamer-Api-Key' => self::API_KEY,
@ -42,7 +42,7 @@ class Beamer extends SimpleWorker {
return true;
}
function getNextRunDate() {
public function getNextRunDate() {
$wp = new WPFunctions;
$date = Carbon::createFromTimestamp($wp->currentTime('timestamp'));
return $date->hour(11)->minute(00)->second(00)->addDay();

14
lib/Cron/Workers/Bounce.php
View File

@ -29,22 +29,22 @@ class Bounce extends SimpleWorker {
/** @var SettingsController */
private $settings;
function __construct(SettingsController $settings) {
public function __construct(SettingsController $settings) {
$this->settings = $settings;
parent::__construct();
}
function init() {
public function init() {
if (!$this->api) {
$this->api = new API($this->settings->get(Mailer::MAILER_CONFIG_SETTING_NAME)['mailpoet_api_key']);
}
}
function checkProcessingRequirements() {
public function checkProcessingRequirements() {
return Bridge::isMPSendingServiceEnabled();
}
function prepareTaskStrategy(ScheduledTask $task, $timer) {
public function prepareTaskStrategy(ScheduledTask $task, $timer) {
BounceTask::prepareSubscribers($task);
if (!ScheduledTaskSubscriber::getUnprocessedCount($task->id)) {
@ -54,7 +54,7 @@ class Bounce extends SimpleWorker {
return true;
}
function processTaskStrategy(ScheduledTask $task, $timer) {
public function processTaskStrategy(ScheduledTask $task, $timer) {
$subscriber_batches = new BatchIterator($task->id, self::BATCH_SIZE);
if (count($subscriber_batches) === 0) {
@ -82,12 +82,12 @@ class Bounce extends SimpleWorker {
return true;
}
function processEmails(array $subscriber_emails) {
public function processEmails(array $subscriber_emails) {
$checked_emails = $this->api->checkBounces($subscriber_emails);
$this->processApiResponse((array)$checked_emails);
}
function processApiResponse(array $checked_emails) {
public function processApiResponse(array $checked_emails) {
foreach ($checked_emails as $email) {
if (!isset($email['address'], $email['bounce'])) {
continue;

2
lib/Cron/Workers/ExportFilesCleanup.php
View File

@ -10,7 +10,7 @@ class ExportFilesCleanup extends SimpleWorker {
const TASK_TYPE = 'export_files_cleanup';
const DELETE_FILES_AFTER_X_DAYS = 1;
function processTaskStrategy(ScheduledTask $task, $timer) {
public function processTaskStrategy(ScheduledTask $task, $timer) {
$iterator = new \GlobIterator(Export::getExportPath() . '/' . Export::getFilePrefix() . '*.*');
foreach ($iterator as $file) {
if (is_string($file)) {

4
lib/Cron/Workers/InactiveSubscribers.php
View File

@ -19,7 +19,7 @@ class InactiveSubscribers extends SimpleWorker {
/** @var SettingsController */
private $settings;
function __construct(
public function __construct(
InactiveSubscribersController $inactive_subscribers_controller,
SettingsController $settings
) {
@ -29,7 +29,7 @@ class InactiveSubscribers extends SimpleWorker {
}
function processTaskStrategy(ScheduledTask $task, $timer) {
public function processTaskStrategy(ScheduledTask $task, $timer) {
$tracking_enabled = (bool)$this->settings->get('tracking.enabled');
if (!$tracking_enabled) {
$this->schedule();

6
lib/Cron/Workers/KeyCheck/KeyCheckWorker.php
View File

@ -9,13 +9,13 @@ use MailPoet\Services\Bridge;
abstract class KeyCheckWorker extends SimpleWorker {
public $bridge;
function init() {
public function init() {
if (!$this->bridge) {
$this->bridge = new Bridge();
}
}
function processTaskStrategy(ScheduledTask $task, $timer) {
public function processTaskStrategy(ScheduledTask $task, $timer) {
try {
$result = $this->checkKey();
} catch (\Exception $e) {
@ -30,5 +30,5 @@ abstract class KeyCheckWorker extends SimpleWorker {
return true;
}
abstract function checkKey();
public abstract function checkKey();
}

6
lib/Cron/Workers/KeyCheck/PremiumKeyCheck.php
View File

@ -11,17 +11,17 @@ class PremiumKeyCheck extends KeyCheckWorker {
/** @var SettingsController */
private $settings;
function __construct(SettingsController $settings) {
public function __construct(SettingsController $settings) {
$this->settings = $settings;
parent::__construct();
}
function checkProcessingRequirements() {
public function checkProcessingRequirements() {
return Bridge::isPremiumKeySpecified();
}
function checkKey() {
public function checkKey() {
$premium_key = $this->settings->get(Bridge::PREMIUM_KEY_SETTING_NAME);
$result = $this->bridge->checkPremiumKey($premium_key);
$this->bridge->storePremiumKeyAndState($premium_key, $result);

6
lib/Cron/Workers/KeyCheck/SendingServiceKeyCheck.php
View File

@ -12,16 +12,16 @@ class SendingServiceKeyCheck extends KeyCheckWorker {
/** @var SettingsController */
private $settings;
function __construct(SettingsController $settings) {
public function __construct(SettingsController $settings) {
$this->settings = $settings;
parent::__construct();
}
function checkProcessingRequirements() {
public function checkProcessingRequirements() {
return Bridge::isMPSendingServiceEnabled();
}
function checkKey() {
public function checkKey() {
$mss_key = $this->settings->get(Mailer::MAILER_CONFIG_SETTING_NAME)['mailpoet_api_key'];
$result = $this->bridge->checkMSSKey($mss_key);
$this->bridge->storeMSSKeyAndState($mss_key, $result);

24
lib/Cron/Workers/Scheduler.php
View File

@ -29,7 +29,7 @@ class Scheduler {
/** @var CronHelper */
private $cron_helper;
function __construct(
public function __construct(
SubscribersFinder $subscribers_finder,
LoggerFactory $logger_factory,
CronHelper $cron_helper
@ -39,7 +39,7 @@ class Scheduler {
$this->logger_factory = $logger_factory;
}
function process($timer = false) {
public function process($timer = false) {
$timer = $timer ?: microtime(true);
// abort if execution limit is reached
@ -67,7 +67,7 @@ class Scheduler {
}
}
function processWelcomeNewsletter($newsletter, $queue) {
public function processWelcomeNewsletter($newsletter, $queue) {
$subscribers = $queue->getSubscribers();
if (empty($subscribers[0])) {
$queue->delete();
@ -90,7 +90,7 @@ class Scheduler {
return true;
}
function processPostNotificationNewsletter($newsletter, $queue) {
public function processPostNotificationNewsletter($newsletter, $queue) {
$this->logger_factory->getLogger(LoggerFactory::TOPIC_POST_NOTIFICATIONS)->addInfo(
'process post notification in scheduler',
['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id]
@ -135,7 +135,7 @@ class Scheduler {
return true;
}
function processScheduledAutomaticEmail($newsletter, $queue) {
public function processScheduledAutomaticEmail($newsletter, $queue) {
if ($newsletter->sendTo === 'segment') {
$segment = Segment::findOne($newsletter->segment);
$result = $this->subscribers_finder->addSubscribersToTaskFromSegments($queue->task(), [$segment]);
@ -159,7 +159,7 @@ class Scheduler {
return true;
}
function processScheduledStandardNewsletter($newsletter, SendingTask $task) {
public function processScheduledStandardNewsletter($newsletter, SendingTask $task) {
$segments = $newsletter->segments()->findMany();
$this->subscribers_finder->addSubscribersToTaskFromSegments($task->task(), $segments);
// update current queue
@ -172,7 +172,7 @@ class Scheduler {
return true;
}
function verifyMailpoetSubscriber($subscriber_id, $newsletter, $queue) {
public function verifyMailpoetSubscriber($subscriber_id, $newsletter, $queue) {
$subscriber = Subscriber::findOne($subscriber_id);
// check if subscriber is in proper segment
$subscriber_in_segment =
@ -187,7 +187,7 @@ class Scheduler {
return $this->verifySubscriber($subscriber, $queue);
}
function verifyWPSubscriber($subscriber_id, $newsletter, $queue) {
public function verifyWPSubscriber($subscriber_id, $newsletter, $queue) {
// check if user has the proper role
$subscriber = Subscriber::findOne($subscriber_id);
if (!$subscriber || $subscriber->isWPUser() === false) {
@ -204,7 +204,7 @@ class Scheduler {
return $this->verifySubscriber($subscriber, $queue);
}
function verifySubscriber($subscriber, $queue) {
public function verifySubscriber($subscriber, $queue) {
if ($subscriber->status === Subscriber::STATUS_UNCONFIRMED) {
// reschedule delivery
$queue->rescheduleProgressively();
@ -216,7 +216,7 @@ class Scheduler {
return true;
}
function deleteQueueOrUpdateNextRunDate($queue, $newsletter) {
public function deleteQueueOrUpdateNextRunDate($queue, $newsletter) {
if ($newsletter->intervalType === PostNotificationScheduler::INTERVAL_IMMEDIATELY) {
$queue->delete();
return;
@ -231,7 +231,7 @@ class Scheduler {
}
}
function createNotificationHistory($newsletter_id) {
public function createNotificationHistory($newsletter_id) {
$newsletter = Newsletter::findOne($newsletter_id);
$notification_history = $newsletter->createNotificationHistory();
return ($notification_history->getErrors() === false) ?
@ -258,7 +258,7 @@ class Scheduler {
}
}
static function getScheduledQueues() {
public static function getScheduledQueues() {
return SendingTask::getScheduledQueues(self::TASK_BATCH_SIZE);
}
}

22
lib/Cron/Workers/SendingQueue/Migration.php
View File

@ -15,13 +15,13 @@ class Migration extends SimpleWorker {
const TASK_TYPE = 'migration';
const BATCH_SIZE = 20;
function checkProcessingRequirements() {
public function checkProcessingRequirements() {
// if migration was completed, don't run it again
$completed_tasks = $this->getCompletedTasks();
return empty($completed_tasks);
}
function prepareTaskStrategy(ScheduledTask $task, $timer) {
public function prepareTaskStrategy(ScheduledTask $task, $timer) {
$unmigrated_columns = $this->checkUnmigratedColumnsExist();
$unmigrated_queues_count = 0;
$unmigrated_queue_subscribers = [];
@ -48,7 +48,7 @@ class Migration extends SimpleWorker {
return true;
}
function pauseSending() {
public function pauseSending() {
$mailer_log = MailerLog::getMailerLog();
if (MailerLog::isSendingPaused($mailer_log)) {
// sending is already paused
@ -62,7 +62,7 @@ class Migration extends SimpleWorker {
return MailerLog::pauseSending($mailer_log);
}
function resumeSending() {
public function resumeSending() {
$mailer_log = MailerLog::getMailerLog();
if (!MailerLog::isSendingPaused($mailer_log)) {
// sending is not paused
@ -75,7 +75,7 @@ class Migration extends SimpleWorker {
}
}
function processTaskStrategy(ScheduledTask $task, $timer) {
public function processTaskStrategy(ScheduledTask $task, $timer) {
$this->migrateSendingQueues($timer);
$this->migrateSubscribers($timer);
$this->resumeSending();
@ -88,12 +88,12 @@ class Migration extends SimpleWorker {
return in_array('type', $existing_columns);
}
function getUnmigratedQueues() {
public function getUnmigratedQueues() {
return SendingQueueModel::where('task_id', 0)
->whereNull('type');
}
function getTaskIdsForUnmigratedSubscribers() {
public function getTaskIdsForUnmigratedSubscribers() {
global $wpdb;
$query = sprintf(
'SELECT queues.`task_id` FROM %1$s queues INNER JOIN %2$s tasks ON queues.`task_id` = tasks.`id` ' .
@ -110,7 +110,7 @@ class Migration extends SimpleWorker {
/*
* Migrate all sending queues without converting subscriber data
*/
function migrateSendingQueues($timer) {
public function migrateSendingQueues($timer) {
global $wpdb;
$queues = $this->getUnmigratedQueues()
@ -160,7 +160,7 @@ class Migration extends SimpleWorker {
/*
* Migrate subscribers for in-progress sending tasks from the `subscribers` field to a separate table
*/
function migrateSubscribers($timer) {
public function migrateSubscribers($timer) {
global $wpdb;
// find in-progress queues that have serialized subscribers
@ -188,7 +188,7 @@ class Migration extends SimpleWorker {
return true;
}
function migrateTaskSubscribers($task_id, $timer) {
public function migrateTaskSubscribers($task_id, $timer) {
global $wpdb;
$migrated_unprocessed_count = ScheduledTaskSubscriber::getUnprocessedCount($task_id);
@ -241,7 +241,7 @@ class Migration extends SimpleWorker {
return true;
}
function getNextRunDate($wp = null) {
public function getNextRunDate($wp = null) {
if (is_null($wp)) {
$wp = new WPFunctions();
}

2
lib/Cron/Workers/SendingQueue/SendingErrorHandler.php
View File

@ -7,7 +7,7 @@ use MailPoet\Mailer\MailerLog;
use MailPoet\Tasks\Sending as SendingTask;
class SendingErrorHandler {
function processError(
public function processError(
MailerError $error,
SendingTask $sending_task,
array $prepared_subscribers_ids,

14
lib/Cron/Workers/SendingQueue/SendingQueue.php
View File

@ -47,7 +47,7 @@ class SendingQueue {
/** @var CronHelper */
private $cron_helper;
function __construct(
public function __construct(
SendingErrorHandler $error_handler,
StatsNotificationsScheduler $stats_notifications_scheduler,
LoggerFactory $logger_factory,
@ -68,7 +68,7 @@ class SendingQueue {
$this->cron_helper = $cron_helper;
}
function process($timer = false) {
public function process($timer = false) {
$timer = $timer ?: microtime(true);
$this->enforceSendingAndExecutionLimits($timer);
foreach (self::getRunningQueues() as $queue) {
@ -165,7 +165,7 @@ class SendingQueue {
}
}
function processQueue($queue, $newsletter, $subscribers, $timer) {
public function processQueue($queue, $newsletter, $subscribers, $timer) {
// determine if processing is done in bulk or individually
$processing_method = $this->mailer_task->getProcessingMethod();
$prepared_newsletters = [];
@ -227,7 +227,7 @@ class SendingQueue {
return $queue;
}
function sendNewsletter(
public function sendNewsletter(
SendingTask $sending_task, $prepared_subscriber_id, $prepared_newsletter,
$prepared_subscriber, $statistics, $timer, $extra_params = []
) {
@ -247,7 +247,7 @@ class SendingQueue {
);
}
function sendNewsletters(
public function sendNewsletters(
SendingTask $sending_task, $prepared_subscribers_ids, $prepared_newsletters,
$prepared_subscribers, $statistics, $timer, $extra_params = []
) {
@ -301,14 +301,14 @@ class SendingQueue {
return $sending_task;
}
function enforceSendingAndExecutionLimits($timer) {
public function enforceSendingAndExecutionLimits($timer) {
// abort if execution limit is reached
$this->cron_helper->enforceExecutionLimit($timer);
// abort if sending limit has been reached
MailerLog::enforceExecutionRequirements();
}
static function getRunningQueues() {
public static function getRunningQueues() {
return SendingTask::getRunningQueues(self::TASK_BATCH_SIZE);
}
}

8
lib/Cron/Workers/SendingQueue/Tasks/Links.php
View File

@ -13,14 +13,14 @@ use MailPoet\Subscription\SubscriptionUrlFactory;
use MailPoet\Util\Helpers;
class Links {
static function process($rendered_newsletter, $newsletter, $queue) {
public static function process($rendered_newsletter, $newsletter, $queue) {
list($rendered_newsletter, $links) =
self::hashAndReplaceLinks($rendered_newsletter, $newsletter->id, $queue->id);
self::saveLinks($links, $newsletter, $queue);
return $rendered_newsletter;
}
static function hashAndReplaceLinks($rendered_newsletter, $newsletter_id, $queue_id) {
public static function hashAndReplaceLinks($rendered_newsletter, $newsletter_id, $queue_id) {
// join HTML and TEXT rendered body into a text string
$content = Helpers::joinObject($rendered_newsletter);
list($content, $links) = NewsletterLinks::process($content, $newsletter_id, $queue_id);
@ -34,11 +34,11 @@ class Links {
];
}
static function saveLinks($links, $newsletter, $queue) {
public static function saveLinks($links, $newsletter, $queue) {
return NewsletterLinks::save($links, $newsletter->id, $queue->id);
}
static function getUnsubscribeUrl($queue, $subscriber_id) {
public static function getUnsubscribeUrl($queue, $subscriber_id) {
$subscriber = Subscriber::where('id', $subscriber_id)->findOne();
$settings = SettingsController::getInstance();
if ((boolean)$settings->get('tracking.enabled')) {

16
lib/Cron/Workers/SendingQueue/Tasks/Mailer.php
View File

@ -8,11 +8,11 @@ use MailPoet\Mailer\MailerLog;
class Mailer {
public $mailer;
function __construct($mailer = false) {
public function __construct($mailer = false) {
$this->mailer = ($mailer) ? $mailer : $this->configureMailer();
}
function configureMailer($newsletter = null) {
public function configureMailer($newsletter = null) {
$sender['address'] = (!empty($newsletter->sender_address)) ?
$newsletter->sender_address :
false;
@ -36,25 +36,25 @@ class Mailer {
return $this->mailer;
}
function getMailerLog() {
public function getMailerLog() {
return MailerLog::getMailerLog();
}
function updateSentCount() {
public function updateSentCount() {
return MailerLog::incrementSentCount();
}
function getProcessingMethod() {
public function getProcessingMethod() {
return ($this->mailer->mailer_config['method'] === MailerFactory::METHOD_MAILPOET) ?
'bulk' :
'individual';
}
function prepareSubscriberForSending($subscriber) {
public function prepareSubscriberForSending($subscriber) {
return $this->mailer->formatSubscriberNameAndEmailAddress($subscriber);
}
function sendBulk($prepared_newsletters, $prepared_subscribers, $extra_params = []) {
public function sendBulk($prepared_newsletters, $prepared_subscribers, $extra_params = []) {
if ($this->getProcessingMethod() === 'individual') {
throw new \LogicException('Trying to send a batch with individual processing method');
}
@ -65,7 +65,7 @@ class Mailer {
);
}
function send($prepared_newsletter, $prepared_subscriber, $extra_params = []) {
public function send($prepared_newsletter, $prepared_subscriber, $extra_params = []) {
if ($this->getProcessingMethod() === 'bulk') {
throw new \LogicException('Trying to send an individual email with a bulk processing method');
}

14
lib/Cron/Workers/SendingQueue/Tasks/Newsletter.php
View File

@ -37,7 +37,7 @@ class Newsletter {
/** @var Emoji */
private $emoji;
function __construct(WPFunctions $wp = null, PostsTask $posts_task = null, GATracking $ga_tracking = null, Emoji $emoji = null) {
public function __construct(WPFunctions $wp = null, PostsTask $posts_task = null, GATracking $ga_tracking = null, Emoji $emoji = null) {
$settings = SettingsController::getInstance();
$this->tracking_enabled = (boolean)$settings->get('tracking.enabled');
if ($wp === null) {
@ -59,7 +59,7 @@ class Newsletter {
$this->emoji = $emoji;
}
function getNewsletterFromQueue($queue) {
public function getNewsletterFromQueue($queue) {
// get existing active or sending newsletter
$newsletter = $queue->newsletter()
->whereNull('deleted_at')
@ -87,7 +87,7 @@ class Newsletter {
return $newsletter;
}
function preProcessNewsletter(\MailPoet\Models\Newsletter $newsletter, $sending_task) {
public function preProcessNewsletter(\MailPoet\Models\Newsletter $newsletter, $sending_task) {
// return the newsletter if it was previously rendered
if (!is_null($sending_task->getNewsletterRenderedBody())) {
return (!$sending_task->validate()) ?
@ -167,7 +167,7 @@ class Newsletter {
return $newsletter;
}
function prepareNewsletterForSending($newsletter, $subscriber, $queue) {
public function prepareNewsletterForSending($newsletter, $subscriber, $queue) {
// shortcodes and links will be replaced in the subject, html and text body
// to speed the processing, join content into a continuous string
$rendered_newsletter = $queue->getNewsletterRenderedBody();
@ -204,7 +204,7 @@ class Newsletter {
];
}
function markNewsletterAsSent($newsletter, $queue) {
public function markNewsletterAsSent($newsletter, $queue) {
// if it's a standard or notification history newsletter, update its status
if ($newsletter->type === NewsletterModel::TYPE_STANDARD ||
$newsletter->type === NewsletterModel::TYPE_NOTIFICATION_HISTORY
@ -215,14 +215,14 @@ class Newsletter {
}
}
function getNewsletterSegments($newsletter) {
public function getNewsletterSegments($newsletter) {
$segments = NewsletterSegmentModel::where('newsletter_id', $newsletter->id)
->select('segment_id')
->findArray();
return Helpers::flattenArray($segments);
}
function stopNewsletterPreProcessing($error_code = null) {
public function stopNewsletterPreProcessing($error_code = null) {
MailerLog::processError(
'queue_save',
WPFunctions::get()->__('There was an error processing your newsletter during sending. If possible, please contact us and report this issue.', 'mailpoet'),

4
lib/Cron/Workers/SendingQueue/Tasks/Posts.php
View File

@ -14,7 +14,7 @@ class Posts {
$this->logger_factory = LoggerFactory::getInstance();
}
function extractAndSave($rendered_newsletter, $newsletter) {
public function extractAndSave($rendered_newsletter, $newsletter) {
if ($newsletter->type !== NewsletterModel::TYPE_NOTIFICATION_HISTORY) {
return false;
}
@ -44,7 +44,7 @@ class Posts {
return true;
}
function getAlcPostsCount($rendered_newsletter, \MailPoet\Models\Newsletter $newsletter) {
public function getAlcPostsCount($rendered_newsletter, \MailPoet\Models\Newsletter $newsletter) {
$template_posts_count = substr_count($newsletter->body, 'data-post-id');
$newsletter_posts_count = substr_count($rendered_newsletter['html'], 'data-post-id');
return $newsletter_posts_count - $template_posts_count;

2
lib/Cron/Workers/SendingQueue/Tasks/Shortcodes.php
View File

@ -5,7 +5,7 @@ namespace MailPoet\Cron\Workers\SendingQueue\Tasks;
use MailPoet\Newsletter\Shortcodes\Shortcodes as NewsletterShortcodes;
class Shortcodes {
static function process($content, $content_source = null, $newsletter = null, $subscriber = null, $queue = null) {
public static function process($content, $content_source = null, $newsletter = null, $subscriber = null, $queue = null) {
$shortcodes = new NewsletterShortcodes($newsletter, $subscriber, $queue);
return $shortcodes->replace($content, $content_source);
}

20
lib/Cron/Workers/SimpleWorker.php
View File

@ -27,7 +27,7 @@ abstract class SimpleWorker implements CronWorkerInterface {
/** @var CronWorkerScheduler */
protected $cron_worker_scheduler;
function __construct() {
public function __construct() {
if (static::TASK_TYPE === null) {
throw new \Exception('Constant TASK_TYPE is not defined on subclass ' . get_class($this));
}
@ -37,34 +37,34 @@ abstract class SimpleWorker implements CronWorkerInterface {
$this->cron_worker_scheduler = ContainerWrapper::getInstance()->get(CronWorkerScheduler::class);
}
function getTaskType() {
public function getTaskType() {
return static::TASK_TYPE;
}
function supportsMultipleInstances() {
public function supportsMultipleInstances() {
return static::SUPPORT_MULTIPLE_INSTANCES;
}
function schedule() {
public function schedule() {
$this->cron_worker_scheduler->schedule(static::TASK_TYPE, $this->getNextRunDate());
}
function checkProcessingRequirements() {
public function checkProcessingRequirements() {
return true;
}
function init() {
public function init() {
}
function prepareTaskStrategy(ScheduledTask $task, $timer) {
public function prepareTaskStrategy(ScheduledTask $task, $timer) {
return true;
}
function processTaskStrategy(ScheduledTask $task, $timer) {
public function processTaskStrategy(ScheduledTask $task, $timer) {
return true;
}
function getNextRunDate() {
public function getNextRunDate() {
// random day of the next week
$date = Carbon::createFromTimestamp($this->wp->currentTime('timestamp'));
$date->setISODate((int)$date->format('o'), ((int)$date->format('W')) + 1, mt_rand(1, 7));
@ -72,7 +72,7 @@ abstract class SimpleWorker implements CronWorkerInterface {
return $date;
}
function scheduleAutomatically() {
public function scheduleAutomatically() {
return static::AUTOMATIC_SCHEDULING;
}

8
lib/Cron/Workers/StatsNotifications/AutomatedEmails.php
View File

@ -37,7 +37,7 @@ class AutomatedEmails extends SimpleWorker {
/** @var NewsletterStatisticsRepository */
private $newsletter_statistics_repository;
function __construct(
public function __construct(
Mailer $mailer,
Renderer $renderer,
SettingsController $settings,
@ -54,7 +54,7 @@ class AutomatedEmails extends SimpleWorker {
$this->newsletter_statistics_repository = $newsletter_statistics_repository;
}
function checkProcessingRequirements() {
public function checkProcessingRequirements() {
$settings = $this->settings->get(Worker::SETTINGS_KEY);
if (!is_array($settings)) {
return false;
@ -74,7 +74,7 @@ class AutomatedEmails extends SimpleWorker {
return (bool)$settings['automated'];
}
function processTaskStrategy(ScheduledTask $task, $timer) {
public function processTaskStrategy(ScheduledTask $task, $timer) {
try {
$settings = $this->settings->get(Worker::SETTINGS_KEY);
$newsletters = $this->getNewsletters();
@ -147,7 +147,7 @@ class AutomatedEmails extends SimpleWorker {
return $context;
}
function getNextRunDate() {
public function getNextRunDate() {
$wp = new WPFunctions;
$date = Carbon::createFromTimestamp($wp->currentTime('timestamp'));
return $date->endOfMonth()->next(Carbon::MONDAY)->midDay();

4
lib/Cron/Workers/StatsNotifications/Scheduler.php
View File

@ -31,7 +31,7 @@ class Scheduler {
/** @var StatsNotificationsRepository */
private $repository;
function __construct(
public function __construct(
SettingsController $settings,
EntityManager $entity_manager,
StatsNotificationsRepository $repository
@ -41,7 +41,7 @@ class Scheduler {
$this->repository = $repository;
}
function schedule(NewsletterEntity $newsletter) {
public function schedule(NewsletterEntity $newsletter) {
if (!$this->shouldSchedule($newsletter)) {
return false;
}

4
lib/Cron/Workers/StatsNotifications/Worker.php
View File

@ -60,7 +60,7 @@ class Worker {
/** @var SubscribersRepository */
private $subscribers_repository;
function __construct(
public function __construct(
Mailer $mailer,
Renderer $renderer,
SettingsController $settings,
@ -87,7 +87,7 @@ class Worker {
}
/** @throws \Exception */
function process($timer = false) {
public function process($timer = false) {
$timer = $timer ?: microtime(true);
$settings = $this->settings->get(self::SETTINGS_KEY);
foreach ($this->repository->findScheduled(Sending::RESULT_BATCH_SIZE) as $stats_notification_entity) {

4
lib/Cron/Workers/SubscriberLinkTokens.php
View File

@ -15,7 +15,7 @@ class SubscriberLinkTokens extends SimpleWorker {
const BATCH_SIZE = 10000;
const AUTOMATIC_SCHEDULING = false;
function processTaskStrategy(ScheduledTask $task, $timer) {
public function processTaskStrategy(ScheduledTask $task, $timer) {
$count = Subscriber::whereNull('link_token')->count();
if ($count) {
$auth_key = defined('AUTH_KEY') ? AUTH_KEY : '';
@ -28,7 +28,7 @@ class SubscriberLinkTokens extends SimpleWorker {
return true;
}
function getNextRunDate() {
public function getNextRunDate() {
$wp = new WPFunctions();
return Carbon::createFromTimestamp($wp->currentTime('timestamp'));
}

4
lib/Cron/Workers/UnsubscribeTokens.php
View File

@ -15,7 +15,7 @@ class UnsubscribeTokens extends SimpleWorker {
const BATCH_SIZE = 1000;
const AUTOMATIC_SCHEDULING = false;
function processTaskStrategy(ScheduledTask $task, $timer) {
public function processTaskStrategy(ScheduledTask $task, $timer) {
$meta = $task->getMeta();
do {
$this->cron_helper->enforceExecutionLimit($timer);
@ -49,7 +49,7 @@ class UnsubscribeTokens extends SimpleWorker {
return count($instances);
}
function getNextRunDate() {
public function getNextRunDate() {
$wp = new WPFunctions;
return Carbon::createFromTimestamp($wp->currentTime('timestamp'));
}

8
lib/Cron/Workers/WooCommercePastOrders.php
View File

@ -20,7 +20,7 @@ class WooCommercePastOrders extends SimpleWorker {
/** @var WooCommercePurchases */
private $woocommerce_purchases;
function __construct(
public function __construct(
WCHelper $woocommerce_helper,
WooCommercePurchases $woocommerce_purchases
) {
@ -29,11 +29,11 @@ class WooCommercePastOrders extends SimpleWorker {
parent::__construct();
}
function checkProcessingRequirements() {
public function checkProcessingRequirements() {
return $this->woocommerce_helper->isWooCommerceActive() && empty($this->getCompletedTasks()); // run only once
}
function processTaskStrategy(ScheduledTask $task, $timer) {
public function processTaskStrategy(ScheduledTask $task, $timer) {
$oldest_click = StatisticsClicks::orderByAsc('created_at')->limit(1)->findOne();
if (!$oldest_click instanceof StatisticsClicks) {
return true;
@ -70,7 +70,7 @@ class WooCommercePastOrders extends SimpleWorker {
return false;
}
function getNextRunDate() {
public function getNextRunDate() {
return Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')); // schedule immediately
}
}

6
lib/Cron/Workers/WooCommerceSync.php
View File

@ -18,17 +18,17 @@ class WooCommerceSync extends SimpleWorker {
/** @var WooCommerceHelper */
private $woocommerce_helper;
function __construct(WooCommerceSegment $woocommerce_segment, WooCommerceHelper $woocommerce_helper) {
public function __construct(WooCommerceSegment $woocommerce_segment, WooCommerceHelper $woocommerce_helper) {
$this->woocommerce_segment = $woocommerce_segment;
$this->woocommerce_helper = $woocommerce_helper;
parent::__construct();
}
function checkProcessingRequirements() {
public function checkProcessingRequirements() {
return $this->woocommerce_helper->isWooCommerceActive();
}
function processTaskStrategy(ScheduledTask $task, $timer) {
public function processTaskStrategy(ScheduledTask $task, $timer) {
$this->woocommerce_segment->synchronizeCustomers();
return true;
}

32
lib/Cron/Workers/WorkersFactory.php
View File

@ -22,82 +22,82 @@ class WorkersFactory {
}
/** @return SchedulerWorker */
function createScheduleWorker() {
public function createScheduleWorker() {
return $this->container->get(SchedulerWorker::class);
}
/** @return SendingQueueWorker */
function createQueueWorker() {
public function createQueueWorker() {
return $this->container->get(SendingQueueWorker::class);
}
/** @return StatsNotificationsWorker */
function createStatsNotificationsWorker() {
public function createStatsNotificationsWorker() {
return $this->container->get(StatsNotificationsWorker::class);
}
/** @return StatsNotificationsWorkerForAutomatedEmails */
function createStatsNotificationsWorkerForAutomatedEmails() {
public function createStatsNotificationsWorkerForAutomatedEmails() {
return $this->container->get(StatsNotificationsWorkerForAutomatedEmails::class);
}
/** @return SendingServiceKeyCheckWorker */
function createSendingServiceKeyCheckWorker() {
public function createSendingServiceKeyCheckWorker() {
return $this->container->get(SendingServiceKeyCheckWorker::class);
}
/** @return PremiumKeyCheckWorker */
function createPremiumKeyCheckWorker() {
public function createPremiumKeyCheckWorker() {
return $this->container->get(PremiumKeyCheckWorker::class);
}
/** @return BounceWorker */
function createBounceWorker() {
public function createBounceWorker() {
return $this->container->get(BounceWorker::class);
}
/** @return MigrationWorker */
function createMigrationWorker() {
public function createMigrationWorker() {
return $this->container->get(MigrationWorker::class);
}
/** @return WooCommerceSyncWorker */
function createWooCommerceSyncWorker() {
public function createWooCommerceSyncWorker() {
return $this->container->get(WooCommerceSyncWorker::class);
}
/** @return ExportFilesCleanup */
function createExportFilesCleanupWorker() {
public function createExportFilesCleanupWorker() {
return $this->container->get(ExportFilesCleanup::class);
}
/** @return Beamer */
function createBeamerkWorker() {
public function createBeamerkWorker() {
return $this->container->get(Beamer::class);
}
/** @return InactiveSubscribers */
function createInactiveSubscribersWorker() {
public function createInactiveSubscribersWorker() {
return $this->container->get(InactiveSubscribers::class);
}
/** @return UnsubscribeTokens */
function createUnsubscribeTokensWorker() {
public function createUnsubscribeTokensWorker() {
return $this->container->get(UnsubscribeTokens::class);
}
/** @return SubscriberLinkTokens */
function createSubscriberLinkTokensWorker() {
public function createSubscriberLinkTokensWorker() {
return $this->container->get(SubscriberLinkTokens::class);
}
/** @return AuthorizedSendingEmailsCheck */
function createAuthorizedSendingEmailsCheckWorker() {
public function createAuthorizedSendingEmailsCheckWorker() {
return $this->container->get(AuthorizedSendingEmailsCheck::class);
}
/** @return WooCommercePastOrders */
function createWooCommercePastOrdersWorker() {
public function createWooCommercePastOrdersWorker() {
return $this->container->get(WooCommercePastOrders::class);
}
}