CRM/Mailing/BAO/MailingJob.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.7                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2017                                |
   7  +--------------------------------------------------------------------+
   8  | This file is a part of CiviCRM.                                    |
   9  |                                                                    |
  10  | CiviCRM is free software; you can copy, modify, and distribute it  |
  11  | under the terms of the GNU Affero General Public License           |
  12  | Version 3, 19 November 2007 and the CiviCRM Licensing Exception.   |
  13  |                                                                    |
  14  | CiviCRM is distributed in the hope that it will be useful, but     |
  15  | WITHOUT ANY WARRANTY; without even the implied warranty of         |
  16  | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.               |
  17  | See the GNU Affero General Public License for more details.        |
  18  |                                                                    |
  19  | You should have received a copy of the GNU Affero General Public   |
  20  | License and the CiviCRM Licensing Exception along                  |
  21  | with this program; if not, contact CiviCRM LLC                     |
  22  | at info[AT]civicrm[DOT]org. If you have questions about the        |
  23  | GNU Affero General Public License or the licensing of CiviCRM,     |
  24  | see the CiviCRM license FAQ at http://civicrm.org/licensing        |
  25  +--------------------------------------------------------------------+
  26  */
  27
  28 /**
  29  *
  30  * @package CRM
  31  * @copyright CiviCRM LLC (c) 2004-2017
  32  */
  33
  34 require_once 'Mail.php';
  35
  36 /**
  37  * Class CRM_Mailing_BAO_MailingJob
  38  */
  39 class CRM_Mailing_BAO_MailingJob extends CRM_Mailing_DAO_MailingJob {
  40   const MAX_CONTACTS_TO_PROCESS = 1000;
  41
  42   /**
  43    * (Dear God Why) Keep a global count of mails processed within the current
  44    * request.
  45    *
  46    * @var int
  47    */
  48   static $mailsProcessed = 0;
  49
  50   /**
  51    * Class constructor.
  52    */
  53   public function __construct() {
  54     parent::__construct();
  55   }
  56
  57   /**
  58    * Create mailing job.
  59    *
  60    * @param array $params
  61    *
  62    * @return \CRM_Mailing_BAO_MailingJob
  63    * @throws \CRM_Core_Exception
  64    */
  65   static public function create($params) {
  66     $job = new CRM_Mailing_BAO_MailingJob();
  67     $job->mailing_id = $params['mailing_id'];
  68     $job->status = $params['status'];
  69     $job->scheduled_date = $params['scheduled_date'];
  70     $job->is_test = $params['is_test'];
  71     $job->save();
  72     $mailing = new CRM_Mailing_BAO_Mailing();
  73     $mailing->id = $params['mailing_id'];
  74     if ($mailing->id && $mailing->find(TRUE)) {
  75       $mailing->getRecipients($job->id, $params['mailing_id'], TRUE, $mailing->dedupe_email);
  76       return $job;
  77     }
  78     else {
  79       throw new CRM_Core_Exception("Failed to create job: Unknown mailing ID");
  80     }
  81   }
  82
  83   /**
  84    * Initiate all pending/ready jobs.
  85    *
  86    * @param array $testParams
  87    * @param string $mode
  88    *
  89    * @return bool|null
  90    */
  91   public static function runJobs($testParams = NULL, $mode = NULL) {
  92     $job = new CRM_Mailing_BAO_MailingJob();
  93
  94     $config = CRM_Core_Config::singleton();
  95     $jobTable = CRM_Mailing_DAO_MailingJob::getTableName();
  96     $mailingTable = CRM_Mailing_DAO_Mailing::getTableName();
  97     $mailerBatchLimit = Civi::settings()->get('mailerBatchLimit');
  98
  99     if (!empty($testParams)) {
 100       $query = "
 101       SELECT *
 102         FROM $jobTable
 103        WHERE id = {$testParams['job_id']}";
 104       $job->query($query);
 105     }
 106     else {
 107       $currentTime = date('YmdHis');
 108       $mailingACL = CRM_Mailing_BAO_Mailing::mailingACL('m');
 109       $domainID = CRM_Core_Config::domainID();
 110
 111       $modeClause = 'AND m.sms_provider_id IS NULL';
 112       if ($mode == 'sms') {
 113         $modeClause = 'AND m.sms_provider_id IS NOT NULL';
 114       }
 115
 116       // Select the first child job that is scheduled
 117       // CRM-6835
 118       $query = "
 119       SELECT   j.*
 120         FROM   $jobTable     j,
 121            $mailingTable m
 122        WHERE   m.id = j.mailing_id AND m.domain_id = {$domainID}
 123                      {$modeClause}
 124          AND   j.is_test = 0
 125          AND   ( ( j.start_date IS null
 126          AND       j.scheduled_date <= $currentTime
 127          AND       j.status = 'Scheduled' )
 128                 OR     ( j.status = 'Running'
 129          AND       j.end_date IS null ) )
 130          AND (j.job_type = 'child')
 131          AND   {$mailingACL}
 132       ORDER BY j.scheduled_date ASC,
 133         j.id
 134       ";
 135
 136       $job->query($query);
 137     }
 138
 139     while ($job->fetch()) {
 140       // still use job level lock for each child job
 141       $lock = Civi::lockManager()->acquire("data.mailing.job.{$job->id}");
 142       if (!$lock->isAcquired()) {
 143         continue;
 144       }
 145
 146       // for test jobs we do not change anything, since its on a short-circuit path
 147       if (empty($testParams)) {
 148         // we've got the lock, but while we were waiting and processing
 149         // other emails, this job might have changed under us
 150         // lets get the job status again and check
 151         $job->status = CRM_Core_DAO::getFieldValue(
 152           'CRM_Mailing_DAO_MailingJob',
 153           $job->id,
 154           'status',
 155           'id',
 156           TRUE
 157         );
 158
 159         if (
 160           $job->status != 'Running' &&
 161           $job->status != 'Scheduled'
 162         ) {
 163           // this includes Cancelled and other statuses, CRM-4246
 164           $lock->release();
 165           continue;
 166         }
 167       }
 168
 169       /* Queue up recipients for the child job being launched */
 170
 171       if ($job->status != 'Running') {
 172         $transaction = new CRM_Core_Transaction();
 173
 174         // have to queue it up based on the offset and limits
 175         // get the parent ID, and limit and offset
 176         $job->queue($testParams);
 177
 178         // Mark up the starting time
 179         $saveJob = new CRM_Mailing_DAO_MailingJob();
 180         $saveJob->id = $job->id;
 181         $saveJob->start_date = date('YmdHis');
 182         $saveJob->status = 'Running';
 183         $saveJob->save();
 184
 185         $transaction->commit();
 186       }
 187
 188       // Get the mailer
 189       if ($mode === NULL) {
 190         $mailer = \Civi::service('pear_mail');
 191       }
 192       elseif ($mode == 'sms') {
 193         $mailer = CRM_SMS_Provider::singleton(array('mailing_id' => $job->mailing_id));
 194       }
 195
 196       // Compose and deliver each child job
 197       if (\CRM_Utils_Constant::value('CIVICRM_FLEXMAILER_HACK_DELIVER')) {
 198         $isComplete = Civi\Core\Resolver::singleton()->call(CIVICRM_FLEXMAILER_HACK_DELIVER, array($job, $mailer, $testParams));
 199       }
 200       else {
 201         $isComplete = $job->deliver($mailer, $testParams);
 202       }
 203
 204       CRM_Utils_Hook::post('create', 'CRM_Mailing_DAO_Spool', $job->id, $isComplete);
 205
 206       // Mark the child complete
 207       if ($isComplete) {
 208         // Finish the job.
 209
 210         $transaction = new CRM_Core_Transaction();
 211
 212         $saveJob = new CRM_Mailing_DAO_MailingJob();
 213         $saveJob->id = $job->id;
 214         $saveJob->end_date = date('YmdHis');
 215         $saveJob->status = 'Complete';
 216         $saveJob->save();
 217
 218         $transaction->commit();
 219
 220         // don't mark the mailing as complete
 221       }
 222
 223       // Release the child joblock
 224       $lock->release();
 225
 226       if ($testParams) {
 227         return $isComplete;
 228       }
 229
 230       // CRM-17629: Stop processing jobs if mailer batch limit reached
 231       if ($mailerBatchLimit > 0 && self::$mailsProcessed >= $mailerBatchLimit) {
 232         break;
 233       }
 234
 235     }
 236   }
 237
 238   /**
 239    * Post process to determine if the parent job
 240    * as well as the mailing is complete after the run.
 241    * @param null $mode
 242    */
 243   public static function runJobs_post($mode = NULL) {
 244
 245     $job = new CRM_Mailing_BAO_MailingJob();
 246
 247     $mailing = new CRM_Mailing_BAO_Mailing();
 248
 249     $config = CRM_Core_Config::singleton();
 250     $jobTable = CRM_Mailing_DAO_MailingJob::getTableName();
 251     $mailingTable = CRM_Mailing_DAO_Mailing::getTableName();
 252
 253     $currentTime = date('YmdHis');
 254     $mailingACL = CRM_Mailing_BAO_Mailing::mailingACL('m');
 255     $domainID = CRM_Core_Config::domainID();
 256
 257     $query = "
 258                 SELECT   j.*
 259                   FROM   $jobTable     j,
 260                                  $mailingTable m
 261                  WHERE   m.id = j.mailing_id AND m.domain_id = {$domainID}
 262                    AND   j.is_test = 0
 263                    AND       j.scheduled_date <= $currentTime
 264                    AND       j.status = 'Running'
 265                    AND       j.end_date IS null
 266                    AND       (j.job_type != 'child' OR j.job_type is NULL)
 267                 ORDER BY j.scheduled_date,
 268                                  j.start_date";
 269
 270     $job->query($query);
 271
 272     // For each parent job that is running, let's look at their child jobs
 273     while ($job->fetch()) {
 274
 275       $child_job = new CRM_Mailing_BAO_MailingJob();
 276
 277       $child_job_sql = "
 278             SELECT count(j.id)
 279                         FROM civicrm_mailing_job j, civicrm_mailing m
 280                         WHERE m.id = j.mailing_id
 281                         AND j.job_type = 'child'
 282                         AND j.parent_id = %1
 283             AND j.status <> 'Complete'";
 284       $params = array(1 => array($job->id, 'Integer'));
 285
 286       $anyChildLeft = CRM_Core_DAO::singleValueQuery($child_job_sql, $params);
 287
 288       // all of the child jobs are complete, update
 289       // the parent job as well as the mailing status
 290       if (!$anyChildLeft) {
 291
 292         $transaction = new CRM_Core_Transaction();
 293
 294         $saveJob = new CRM_Mailing_DAO_MailingJob();
 295         $saveJob->id = $job->id;
 296         $saveJob->end_date = date('YmdHis');
 297         $saveJob->status = 'Complete';
 298         $saveJob->save();
 299
 300         $mailing->reset();
 301         $mailing->id = $job->mailing_id;
 302         $mailing->is_completed = TRUE;
 303         $mailing->save();
 304         $transaction->commit();
 305
 306         // CRM-17763
 307         CRM_Utils_Hook::postMailing($job->mailing_id);
 308       }
 309     }
 310   }
 311
 312
 313   /**
 314    * before we run jobs, we need to split the jobs
 315    * @param int $offset
 316    * @param null $mode
 317    */
 318   public static function runJobs_pre($offset = 200, $mode = NULL) {
 319     $job = new CRM_Mailing_BAO_MailingJob();
 320
 321     $jobTable = CRM_Mailing_DAO_MailingJob::getTableName();
 322     $mailingTable = CRM_Mailing_DAO_Mailing::getTableName();
 323
 324     $currentTime = date('YmdHis');
 325     $mailingACL = CRM_Mailing_BAO_Mailing::mailingACL('m');
 326
 327     $workflowClause = CRM_Mailing_BAO_MailingJob::workflowClause();
 328
 329     $domainID = CRM_Core_Config::domainID();
 330
 331     $modeClause = 'AND m.sms_provider_id IS NULL';
 332     if ($mode == 'sms') {
 333       $modeClause = 'AND m.sms_provider_id IS NOT NULL';
 334     }
 335
 336     // Select all the mailing jobs that are created from
 337     // when the mailing is submitted or scheduled.
 338     $query = "
 339     SELECT   j.*
 340       FROM   $jobTable     j,
 341          $mailingTable m
 342      WHERE   m.id = j.mailing_id AND m.domain_id = {$domainID}
 343                  $workflowClause
 344                  $modeClause
 345        AND   j.is_test = 0
 346        AND   ( ( j.start_date IS null
 347        AND       j.scheduled_date <= $currentTime
 348        AND       j.status = 'Scheduled'
 349        AND       j.end_date IS null ) )
 350        AND ((j.job_type is NULL) OR (j.job_type <> 'child'))
 351     ORDER BY j.scheduled_date,
 352          j.start_date";
 353
 354     $job->query($query);
 355
 356     // For each of the "Parent Jobs" we find, we split them into
 357     // X Number of child jobs
 358     while ($job->fetch()) {
 359       // still use job level lock for each child job
 360       $lock = Civi::lockManager()->acquire("data.mailing.job.{$job->id}");
 361       if (!$lock->isAcquired()) {
 362         continue;
 363       }
 364
 365       // Re-fetch the job status in case things
 366       // changed between the first query and now
 367       // to avoid race conditions
 368       $job->status = CRM_Core_DAO::getFieldValue(
 369         'CRM_Mailing_DAO_MailingJob',
 370         $job->id,
 371         'status',
 372         'id',
 373         TRUE
 374       );
 375       if ($job->status != 'Scheduled') {
 376         $lock->release();
 377         continue;
 378       }
 379
 380       $job->split_job($offset);
 381
 382       // update the status of the parent job
 383       $transaction = new CRM_Core_Transaction();
 384
 385       $saveJob = new CRM_Mailing_DAO_MailingJob();
 386       $saveJob->id = $job->id;
 387       $saveJob->start_date = date('YmdHis');
 388       $saveJob->status = 'Running';
 389       $saveJob->save();
 390
 391       $transaction->commit();
 392
 393       // Release the job lock
 394       $lock->release();
 395     }
 396   }
 397
 398   /**
 399    * Split the parent job into n number of child job based on an offset.
 400    * If null or 0 , we create only one child job
 401    * @param int $offset
 402    */
 403   public function split_job($offset = 200) {
 404     $recipient_count = CRM_Mailing_BAO_Recipients::mailingSize($this->mailing_id);
 405
 406     $jobTable = CRM_Mailing_DAO_MailingJob::getTableName();
 407
 408     $dao = new CRM_Core_DAO();
 409
 410     $sql = "
 411 INSERT INTO civicrm_mailing_job
 412 (`mailing_id`, `scheduled_date`, `status`, `job_type`, `parent_id`, `job_offset`, `job_limit`)
 413 VALUES (%1, %2, %3, %4, %5, %6, %7)
 414 ";
 415     $params = array(
 416       1 => array($this->mailing_id, 'Integer'),
 417       2 => array($this->scheduled_date, 'String'),
 418       3 => array('Scheduled', 'String'),
 419       4 => array('child', 'String'),
 420       5 => array($this->id, 'Integer'),
 421       6 => array(0, 'Integer'),
 422       7 => array($recipient_count, 'Integer'),
 423     );
 424
 425     // create one child job if the mailing size is less than the offset
 426     // probably use a CRM_Mailing_DAO_MailingJob( );
 427     if (empty($offset) ||
 428       $recipient_count <= $offset
 429     ) {
 430       CRM_Core_DAO::executeQuery($sql, $params);
 431     }
 432     else {
 433       // Creating 'child jobs'
 434       $scheduled_unixtime = strtotime($this->scheduled_date);
 435       for ($i = 0, $s = 0; $i < $recipient_count; $i = $i + $offset, $s++) {
 436         $params[2][0] = date('Y-m-d H:i:s', $scheduled_unixtime + $s);
 437         $params[6][0] = $i;
 438         $params[7][0] = $offset;
 439         CRM_Core_DAO::executeQuery($sql, $params);
 440       }
 441     }
 442   }
 443
 444   /**
 445    * @param array $testParams
 446    */
 447   public function queue($testParams = NULL) {
 448     $mailing = new CRM_Mailing_BAO_Mailing();
 449     $mailing->id = $this->mailing_id;
 450     if (!empty($testParams)) {
 451       $mailing->getTestRecipients($testParams);
 452     }
 453     else {
 454       // We are still getting all the recipients from the parent job
 455       // so we don't mess with the include/exclude logic.
 456       $recipients = CRM_Mailing_BAO_Recipients::mailingQuery($this->mailing_id, $this->job_offset, $this->job_limit);
 457
 458       // FIXME: this is not very smart, we should move this to one DB call
 459       // INSERT INTO ... SELECT FROM ..
 460       // the thing we need to figure out is how to generate the hash automatically
 461       $now = time();
 462       $params = array();
 463       $count = 0;
 464       while ($recipients->fetch()) {
 465         // CRM-18543: there are situations when both the email and phone are null.
 466         // Skip the recipient in this case.
 467         if (empty($recipients->email_id) && empty($recipients->phone_id)) {
 468           continue;
 469         }
 470
 471         if ($recipients->phone_id) {
 472           $recipients->email_id = "null";
 473         }
 474         else {
 475           $recipients->phone_id = "null";
 476         }
 477
 478         $params[] = array(
 479           $this->id,
 480           $recipients->email_id,
 481           $recipients->contact_id,
 482           $recipients->phone_id,
 483         );
 484         $count++;
 485         if ($count % CRM_Mailing_Config::BULK_MAIL_INSERT_COUNT == 0) {
 486           CRM_Mailing_Event_BAO_Queue::bulkCreate($params, $now);
 487           $count = 0;
 488           $params = array();
 489         }
 490       }
 491
 492       if (!empty($params)) {
 493         CRM_Mailing_Event_BAO_Queue::bulkCreate($params, $now);
 494       }
 495     }
 496   }
 497
 498   /**
 499    * Send the mailing.
 500    *
 501    * @deprecated
 502    *   This is used by CiviMail but will be made redundant by FlexMailer.
 503    * @param object $mailer
 504    *   A Mail object to send the messages.
 505    *
 506    * @param array $testParams
 507    * @return bool
 508    */
 509   public function deliver(&$mailer, $testParams = NULL) {
 510     if (\Civi::settings()->get('experimentalFlexMailerEngine')) {
 511       throw new \RuntimeException("Cannot use legacy deliver() when experimentalFlexMailerEngine is enabled");
 512     }
 513
 514     $mailing = new CRM_Mailing_BAO_Mailing();
 515     $mailing->id = $this->mailing_id;
 516     $mailing->find(TRUE);
 517     $mailing->free();
 518
 519     $config = NULL;
 520
 521     if ($config == NULL) {
 522       $config = CRM_Core_Config::singleton();
 523     }
 524
 525     if (property_exists($mailing, 'language') && $mailing->language && $mailing->language != 'en_US') {
 526       $swapLang = CRM_Utils_AutoClean::swap('global://dbLocale?getter', 'call://i18n/setLocale', $mailing->language);
 527     }
 528
 529     $job_date = CRM_Utils_Date::isoToMysql($this->scheduled_date);
 530     $fields = array();
 531
 532     if (!empty($testParams)) {
 533       $mailing->subject = ts('[CiviMail Draft]') . ' ' . $mailing->subject;
 534     }
 535
 536     CRM_Mailing_BAO_Mailing::tokenReplace($mailing);
 537
 538     // get and format attachments
 539     $attachments = CRM_Core_BAO_File::getEntityFile('civicrm_mailing', $mailing->id);
 540
 541     if (defined('CIVICRM_MAIL_SMARTY') && CIVICRM_MAIL_SMARTY) {
 542       CRM_Core_Smarty::registerStringResource();
 543     }
 544
 545     // CRM-12376
 546     // This handles the edge case scenario where all the mails
 547     // have been delivered in prior jobs.
 548     $isDelivered = TRUE;
 549
 550     // make sure that there's no more than $mailerBatchLimit mails processed in a run
 551     $mailerBatchLimit = Civi::settings()->get('mailerBatchLimit');
 552     $eq = self::findPendingTasks($this->id, $mailing->sms_provider_id ? 'sms' : 'email');
 553     while ($eq->fetch()) {
 554       if ($mailerBatchLimit > 0 && self::$mailsProcessed >= $mailerBatchLimit) {
 555         if (!empty($fields)) {
 556           $this->deliverGroup($fields, $mailing, $mailer, $job_date, $attachments);
 557         }
 558         $eq->free();
 559         return FALSE;
 560       }
 561       self::$mailsProcessed++;
 562
 563       $fields[] = array(
 564         'id' => $eq->id,
 565         'hash' => $eq->hash,
 566         'contact_id' => $eq->contact_id,
 567         'email' => $eq->email,
 568         'phone' => $eq->phone,
 569       );
 570       if (count($fields) == self::MAX_CONTACTS_TO_PROCESS) {
 571         $isDelivered = $this->deliverGroup($fields, $mailing, $mailer, $job_date, $attachments);
 572         if (!$isDelivered) {
 573           $eq->free();
 574           return $isDelivered;
 575         }
 576         $fields = array();
 577       }
 578     }
 579
 580     $eq->free();
 581
 582     if (!empty($fields)) {
 583       $isDelivered = $this->deliverGroup($fields, $mailing, $mailer, $job_date, $attachments);
 584     }
 585     return $isDelivered;
 586   }
 587
 588   /**
 589    * @deprecated
 590    *   This is used by CiviMail but will be made redundant by FlexMailer.
 591    * @param array $fields
 592    *   List of intended recipients.
 593    *   Each recipient is an array with keys 'hash', 'contact_id', 'email', etc.
 594    * @param $mailing
 595    * @param $mailer
 596    * @param $job_date
 597    * @param $attachments
 598    *
 599    * @return bool|null
 600    * @throws Exception
 601    */
 602   public function deliverGroup(&$fields, &$mailing, &$mailer, &$job_date, &$attachments) {
 603     static $smtpConnectionErrors = 0;
 604
 605     if (!is_object($mailer) || empty($fields)) {
 606       CRM_Core_Error::fatal();
 607     }
 608
 609     // get the return properties
 610     $returnProperties = $mailing->getReturnProperties();
 611     $params = $targetParams = $deliveredParams = array();
 612     $count = 0;
 613
 614     // CRM-15702: Sending bulk sms to contacts without e-mail address fails.
 615     // Solution is to skip checking for on hold
 616     $skipOnHold = TRUE;    //do include a statement to check wether e-mail address is on hold
 617     if ($mailing->sms_provider_id) {
 618       $skipOnHold = FALSE; //do not include a statement to check wether e-mail address is on hold
 619     }
 620
 621     foreach ($fields as $key => $field) {
 622       $params[] = $field['contact_id'];
 623     }
 624
 625     $details = CRM_Utils_Token::getTokenDetails(
 626       $params,
 627       $returnProperties,
 628       $skipOnHold, TRUE, NULL,
 629       $mailing->getFlattenedTokens(),
 630       get_class($this),
 631       $this->id
 632     );
 633
 634     $config = CRM_Core_Config::singleton();
 635     foreach ($fields as $key => $field) {
 636       $contactID = $field['contact_id'];
 637       if (!array_key_exists($contactID, $details[0])) {
 638         $details[0][$contactID] = array();
 639       }
 640
 641       // Compose the mailing.
 642       $recipient = $replyToEmail = NULL;
 643       $replyValue = strcmp($mailing->replyto_email, $mailing->from_email);
 644       if ($replyValue) {
 645         $replyToEmail = $mailing->replyto_email;
 646       }
 647
 648       $message = $mailing->compose(
 649         $this->id, $field['id'], $field['hash'],
 650         $field['contact_id'], $field['email'],
 651         $recipient, FALSE, $details[0][$contactID], $attachments,
 652         FALSE, NULL, $replyToEmail
 653       );
 654       if (empty($message)) {
 655         // lets keep the message in the queue
 656         // most likely a permissions related issue with smarty templates
 657         // or a bad contact id? CRM-9833
 658         continue;
 659       }
 660
 661       // Send the mailing.
 662
 663       $body = &$message->get();
 664       $headers = &$message->headers();
 665
 666       if ($mailing->sms_provider_id) {
 667         $provider = CRM_SMS_Provider::singleton(array('mailing_id' => $mailing->id));
 668         $body = $provider->getMessage($message, $field['contact_id'], $details[0][$contactID]);
 669         $headers = $provider->getRecipientDetails($field, $details[0][$contactID]);
 670       }
 671
 672       // make $recipient actually be the *encoded* header, so as not to baffle Mail_RFC822, CRM-5743
 673       $recipient = $headers['To'];
 674       $result = NULL;
 675
 676       // disable error reporting on real mailings (but leave error reporting for tests), CRM-5744
 677       if ($job_date) {
 678         $errorScope = CRM_Core_TemporaryErrorScope::ignoreException();
 679       }
 680
 681       $result = $mailer->send($recipient, $headers, $body, $this->id);
 682
 683       if ($job_date) {
 684         unset($errorScope);
 685       }
 686
 687       if (is_a($result, 'PEAR_Error') && !$mailing->sms_provider_id) {
 688         // CRM-9191
 689         $message = $result->getMessage();
 690         if (
 691           strpos($message, 'Failed to write to socket') !== FALSE ||
 692           strpos($message, 'Failed to set sender') !== FALSE
 693         ) {
 694           // lets log this message and code
 695           $code = $result->getCode();
 696           CRM_Core_Error::debug_log_message("SMTP Socket Error or failed to set sender error. Message: $message, Code: $code");
 697
 698           // these are socket write errors which most likely means smtp connection errors
 699           // lets skip them
 700           $smtpConnectionErrors++;
 701           if ($smtpConnectionErrors <= 5) {
 702             continue;
 703           }
 704
 705           // seems like we have too many of them in a row, we should
 706           // write stuff to disk and abort the cron job
 707           $this->writeToDB(
 708             $deliveredParams,
 709             $targetParams,
 710             $mailing,
 711             $job_date
 712           );
 713
 714           CRM_Core_Error::debug_log_message("Too many SMTP Socket Errors. Exiting");
 715           CRM_Utils_System::civiExit();
 716         }
 717
 718         // Register the bounce event.
 719
 720         $params = array(
 721           'event_queue_id' => $field['id'],
 722           'job_id' => $this->id,
 723           'hash' => $field['hash'],
 724         );
 725         $params = array_merge($params,
 726           CRM_Mailing_BAO_BouncePattern::match($result->getMessage())
 727         );
 728         CRM_Mailing_Event_BAO_Bounce::create($params);
 729       }
 730       elseif (is_a($result, 'PEAR_Error') && $mailing->sms_provider_id) {
 731         // Handle SMS errors: CRM-15426
 732         $job_id = intval($this->id);
 733         $mailing_id = intval($mailing->id);
 734         CRM_Core_Error::debug_log_message("Failed to send SMS message. Vars: mailing_id: ${mailing_id}, job_id: ${job_id}. Error message follows.");
 735         CRM_Core_Error::debug_log_message($result->getMessage());
 736       }
 737       else {
 738         // Register the delivery event.
 739         $deliveredParams[] = $field['id'];
 740         $targetParams[] = $field['contact_id'];
 741
 742         $count++;
 743         if ($count % CRM_Mailing_Config::BULK_MAIL_INSERT_COUNT == 0) {
 744           $this->writeToDB(
 745             $deliveredParams,
 746             $targetParams,
 747             $mailing,
 748             $job_date
 749           );
 750           $count = 0;
 751
 752           // hack to stop mailing job at run time, CRM-4246.
 753           // to avoid making too many DB calls for this rare case
 754           // lets do it when we snapshot
 755           $status = CRM_Core_DAO::getFieldValue(
 756             'CRM_Mailing_DAO_MailingJob',
 757             $this->id,
 758             'status',
 759             'id',
 760             TRUE
 761           );
 762
 763           if ($status != 'Running') {
 764             return FALSE;
 765           }
 766         }
 767       }
 768
 769       unset($result);
 770
 771       // seems like a successful delivery or bounce, lets decrement error count
 772       // only if we have smtp connection errors
 773       if ($smtpConnectionErrors > 0) {
 774         $smtpConnectionErrors--;
 775       }
 776
 777       // If we have enabled the Throttle option, this is the time to enforce it.
 778       $mailThrottleTime = Civi::settings()->get('mailThrottleTime');
 779       if (!empty($mailThrottleTime)) {
 780         usleep((int ) $mailThrottleTime);
 781       }
 782     }
 783
 784     $result = $this->writeToDB(
 785       $deliveredParams,
 786       $targetParams,
 787       $mailing,
 788       $job_date
 789     );
 790
 791     return $result;
 792   }
 793
 794   /**
 795    * Cancel a mailing.
 796    *
 797    * @param int $mailingId
 798    *   The id of the mailing to be canceled.
 799    */
 800   public static function cancel($mailingId) {
 801     $sql = "
 802 SELECT *
 803 FROM   civicrm_mailing_job
 804 WHERE  mailing_id = %1
 805 AND    is_test = 0
 806 AND    ( ( job_type IS NULL ) OR
 807            job_type <> 'child' )
 808 ";
 809     $params = array(1 => array($mailingId, 'Integer'));
 810     $job = CRM_Core_DAO::executeQuery($sql, $params);
 811     if ($job->fetch() &&
 812       in_array($job->status, array('Scheduled', 'Running', 'Paused'))
 813     ) {
 814
 815       $newJob = new CRM_Mailing_BAO_MailingJob();
 816       $newJob->id = $job->id;
 817       $newJob->end_date = date('YmdHis');
 818       $newJob->status = 'Canceled';
 819       $newJob->save();
 820
 821       // also cancel all child jobs
 822       $sql = "
 823 UPDATE civicrm_mailing_job
 824 SET    status = 'Canceled',
 825        end_date = %2
 826 WHERE  parent_id = %1
 827 AND    is_test = 0
 828 AND    job_type = 'child'
 829 AND    status IN ( 'Scheduled', 'Running', 'Paused' )
 830 ";
 831       $params = array(
 832         1 => array($job->id, 'Integer'),
 833         2 => array(date('YmdHis'), 'Timestamp'),
 834       );
 835       CRM_Core_DAO::executeQuery($sql, $params);
 836
 837       CRM_Core_Session::setStatus(ts('The mailing has been canceled.'), ts('Canceled'), 'success');
 838     }
 839   }
 840
 841   /**
 842    * Return a translated status enum string.
 843    *
 844    * @param string $status
 845    *   The status enum.
 846    *
 847    * @return string
 848    *   The translated version
 849    */
 850   public static function status($status) {
 851     static $translation = NULL;
 852
 853     if (empty($translation)) {
 854       $translation = array(
 855         'Scheduled' => ts('Scheduled'),
 856         'Running' => ts('Running'),
 857         'Complete' => ts('Complete'),
 858         'Paused' => ts('Paused'),
 859         'Canceled' => ts('Canceled'),
 860       );
 861     }
 862     return CRM_Utils_Array::value($status, $translation, ts('Not scheduled'));
 863   }
 864
 865   /**
 866    * Return a workflow clause for use in SQL queries,
 867    * to only process jobs that are approved.
 868    *
 869    * @return string
 870    *   For use in a WHERE clause
 871    */
 872   public static function workflowClause() {
 873     // add an additional check and only process
 874     // jobs that are approved
 875     if (CRM_Mailing_Info::workflowEnabled()) {
 876       $approveOptionID = CRM_Core_OptionGroup::getValue('mail_approval_status',
 877         'Approved',
 878         'name'
 879       );
 880       if ($approveOptionID) {
 881         return " AND m.approval_status_id = $approveOptionID ";
 882       }
 883     }
 884     return '';
 885   }
 886
 887   /**
 888    * @param array $deliveredParams
 889    * @param array $targetParams
 890    * @param $mailing
 891    * @param $job_date
 892    *
 893    * @return bool
 894    * @throws CRM_Core_Exception
 895    * @throws Exception
 896    */
 897   public function writeToDB(
 898     &$deliveredParams,
 899     &$targetParams,
 900     &$mailing,
 901     $job_date
 902   ) {
 903     static $activityTypeID = NULL;
 904     static $writeActivity = NULL;
 905
 906     if (!empty($deliveredParams)) {
 907       CRM_Mailing_Event_BAO_Delivered::bulkCreate($deliveredParams);
 908       $deliveredParams = array();
 909     }
 910
 911     if ($writeActivity === NULL) {
 912       $writeActivity = Civi::settings()->get('write_activity_record');
 913     }
 914
 915     if (!$writeActivity) {
 916       return TRUE;
 917     }
 918
 919     $result = TRUE;
 920     if (!empty($targetParams) && !empty($mailing->scheduled_id)) {
 921       if (!$activityTypeID) {
 922         if ($mailing->sms_provider_id) {
 923           $mailing->subject = $mailing->name;
 924           $activityTypeID = CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', 'Mass SMS'
 925           );
 926         }
 927         else {
 928           $activityTypeID = CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', 'Bulk Email');
 929         }
 930         if (!$activityTypeID) {
 931           CRM_Core_Error::fatal();
 932         }
 933       }
 934
 935       $activity = array(
 936         'source_contact_id' => $mailing->scheduled_id,
 937         // CRM-9519
 938         'target_contact_id' => array_unique($targetParams),
 939         'activity_type_id' => $activityTypeID,
 940         'source_record_id' => $this->mailing_id,
 941         'activity_date_time' => $job_date,
 942         'subject' => $mailing->subject,
 943         'status_id' => 2,
 944         'deleteActivityTarget' => FALSE,
 945         'campaign_id' => $mailing->campaign_id,
 946       );
 947
 948       //check whether activity is already created for this mailing.
 949       //if yes then create only target contact record.
 950       $query = "
 951 SELECT id
 952 FROM   civicrm_activity
 953 WHERE  civicrm_activity.activity_type_id = %1
 954 AND    civicrm_activity.source_record_id = %2
 955 ";
 956
 957       $queryParams = array(
 958         1 => array($activityTypeID, 'Integer'),
 959         2 => array($this->mailing_id, 'Integer'),
 960       );
 961       $activityID = CRM_Core_DAO::singleValueQuery($query, $queryParams);
 962
 963       if ($activityID) {
 964         $activity['id'] = $activityID;
 965
 966         // CRM-9519
 967         if (CRM_Core_BAO_Email::isMultipleBulkMail()) {
 968           static $targetRecordID = NULL;
 969           if (!$targetRecordID) {
 970             $activityContacts = CRM_Activity_BAO_ActivityContact::buildOptions('record_type_id', 'validate');
 971             $targetRecordID = CRM_Utils_Array::key('Activity Targets', $activityContacts);
 972           }
 973
 974           // make sure we don't attempt to duplicate the target activity
 975           foreach ($activity['target_contact_id'] as $key => $targetID) {
 976             $sql = "
 977 SELECT id
 978 FROM   civicrm_activity_contact
 979 WHERE  activity_id = $activityID
 980 AND    contact_id = $targetID
 981 AND    record_type_id = $targetRecordID
 982 ";
 983             if (CRM_Core_DAO::singleValueQuery($sql)) {
 984               unset($activity['target_contact_id'][$key]);
 985             }
 986           }
 987         }
 988       }
 989
 990       if (is_a(CRM_Activity_BAO_Activity::create($activity), 'CRM_Core_Error')) {
 991         $result = FALSE;
 992       }
 993
 994       $targetParams = array();
 995     }
 996
 997     return $result;
 998   }
 999
1000   /**
1001    * Search the mailing-event queue for a list of pending delivery tasks.
1002    *
1003    * @param int $jobId
1004    * @param string $medium
1005    *   Ex: 'email' or 'sms'.
1006    *
1007    * @return \CRM_Mailing_Event_BAO_Queue
1008    *   A query object whose rows provide ('id', 'contact_id', 'hash') and ('email' or 'phone').
1009    */
1010   public static function findPendingTasks($jobId, $medium) {
1011     $eq = new CRM_Mailing_Event_BAO_Queue();
1012     $queueTable = CRM_Mailing_Event_BAO_Queue::getTableName();
1013     $emailTable = CRM_Core_BAO_Email::getTableName();
1014     $phoneTable = CRM_Core_BAO_Phone::getTableName();
1015     $contactTable = CRM_Contact_BAO_Contact::getTableName();
1016     $deliveredTable = CRM_Mailing_Event_BAO_Delivered::getTableName();
1017     $bounceTable = CRM_Mailing_Event_BAO_Bounce::getTableName();
1018
1019     $query = "  SELECT      $queueTable.id,
1020                                 $emailTable.email as email,
1021                                 $queueTable.contact_id,
1022                                 $queueTable.hash,
1023                                 NULL as phone
1024                     FROM        $queueTable
1025                     INNER JOIN  $emailTable
1026                             ON  $queueTable.email_id = $emailTable.id
1027                     INNER JOIN  $contactTable
1028                             ON  $contactTable.id = $emailTable.contact_id
1029                     LEFT JOIN   $deliveredTable
1030                             ON  $queueTable.id = $deliveredTable.event_queue_id
1031                     LEFT JOIN   $bounceTable
1032                             ON  $queueTable.id = $bounceTable.event_queue_id
1033                     WHERE       $queueTable.job_id = " . $jobId . "
1034                         AND     $deliveredTable.id IS null
1035                         AND     $bounceTable.id IS null
1036                         AND    $contactTable.is_opt_out = 0";
1037
1038     if ($medium === 'sms') {
1039       $query = "
1040                     SELECT      $queueTable.id,
1041                                 $phoneTable.phone as phone,
1042                                 $queueTable.contact_id,
1043                                 $queueTable.hash,
1044                                 NULL as email
1045                     FROM        $queueTable
1046                     INNER JOIN  $phoneTable
1047                             ON  $queueTable.phone_id = $phoneTable.id
1048                     INNER JOIN  $contactTable
1049                             ON  $contactTable.id = $phoneTable.contact_id
1050                     LEFT JOIN   $deliveredTable
1051                             ON  $queueTable.id = $deliveredTable.event_queue_id
1052                     LEFT JOIN   $bounceTable
1053                             ON  $queueTable.id = $bounceTable.event_queue_id
1054                     WHERE       $queueTable.job_id = " . $jobId . "
1055                         AND     $deliveredTable.id IS null
1056                         AND     $bounceTable.id IS null
1057                         AND    ( $contactTable.is_opt_out = 0
1058                         OR       $contactTable.do_not_sms = 0 )";
1059     }
1060     $eq->query($query);
1061     return $eq;
1062   }
1063
1064 }