CRM/Mailing/BAO/MailingJob.php

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