CRM/Contribute/BAO/Contribution.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 5                                                  |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2019                                |
   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-2019
  32  */
  33 class CRM_Contribute_BAO_Contribution extends CRM_Contribute_DAO_Contribution {
  34
  35   /**
  36    * Static field for all the contribution information that we can potentially import
  37    *
  38    * @var array
  39    */
  40   static $_importableFields = NULL;
  41
  42   /**
  43    * Static field for all the contribution information that we can potentially export
  44    *
  45    * @var array
  46    */
  47   static $_exportableFields = NULL;
  48
  49   /**
  50    * Static field to hold financial trxn id's.
  51    *
  52    * @var array
  53    */
  54   static $_trxnIDs = NULL;
  55
  56   /**
  57    * Field for all the objects related to this contribution
  58    * @var array of objects (e.g membership object, participant object)
  59    */
  60   public $_relatedObjects = array();
  61
  62   /**
  63    * Field for the component - either 'event' (participant) or 'contribute'
  64    * (any item related to a contribution page e.g. membership, pledge, contribution)
  65    * This is used for composing messages because they have dependency on the
  66    * contribution_page or event page - although over time we may eliminate that
  67    *
  68    * @var string component or event
  69    */
  70   public $_component = NULL;
  71
  72   /**
  73    * Possibly obsolete variable.
  74    *
  75    * If you use it please explain why it is set in the create function here.
  76    *
  77    * @var string
  78    */
  79   public $trxn_result_code;
  80
  81   /**
  82    * Class constructor.
  83    */
  84   public function __construct() {
  85     parent::__construct();
  86   }
  87
  88   /**
  89    * Takes an associative array and creates a contribution object.
  90    *
  91    * the function extract all the params it needs to initialize the create a
  92    * contribution object. the params array could contain additional unused name/value
  93    * pairs
  94    *
  95    * @param array $params
  96    *   (reference ) an assoc array of name/value pairs.
  97    * @param array $ids
  98    *   The array that holds all the db ids.
  99    *
 100    * @return \CRM_Contribute_BAO_Contribution
 101    * @throws \CRM_Core_Exception
 102    */
 103   public static function add(&$params, $ids = array()) {
 104     if (empty($params)) {
 105       return NULL;
 106     }
 107     //per http://wiki.civicrm.org/confluence/display/CRM/Database+layer we are moving away from $ids array
 108     $contributionID = CRM_Utils_Array::value('contribution', $ids, CRM_Utils_Array::value('id', $params));
 109     $duplicates = array();
 110     if (self::checkDuplicate($params, $duplicates, $contributionID)) {
 111       $message = ts("Duplicate error - existing contribution record(s) have a matching Transaction ID or Invoice ID. Contribution record ID(s) are: " . implode(', ', $duplicates));
 112       throw new CRM_Core_Exception($message);
 113     }
 114
 115     // first clean up all the money fields
 116     $moneyFields = array(
 117       'total_amount',
 118       'net_amount',
 119       'fee_amount',
 120       'non_deductible_amount',
 121     );
 122
 123     //if priceset is used, no need to cleanup money
 124     if (!empty($params['skipCleanMoney'])) {
 125       $moneyFields = [];
 126     }
 127     else {
 128       // @todo put a deprecated here - this should be done in the form layer.
 129       $params['skipCleanMoney'] = FALSE;
 130       Civi::log()->warning('Deprecated code path. Money should always be clean before it hits the BAO.', array('civi.tag' => 'deprecated'));
 131     }
 132
 133     foreach ($moneyFields as $field) {
 134       if (isset($params[$field])) {
 135         $params[$field] = CRM_Utils_Rule::cleanMoney($params[$field]);
 136       }
 137     }
 138
 139     //set defaults in create mode
 140     if (!$contributionID) {
 141       CRM_Core_DAO::setCreateDefaults($params, self::getDefaults());
 142
 143       if (empty($params['invoice_number'])) {
 144         $nextContributionID = CRM_Core_DAO::singleValueQuery("SELECT COALESCE(MAX(id) + 1, 1) FROM civicrm_contribution");
 145         $params['invoice_number'] = self::getInvoiceNumber($nextContributionID);
 146       }
 147     }
 148
 149     $contributionStatus = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
 150     //if contribution is created with cancelled or refunded status, add credit note id
 151     if (!empty($params['contribution_status_id'])) {
 152       // @todo - should we include Chargeback? If so use self::isContributionStatusNegative($params['contribution_status_id'])
 153       if (($params['contribution_status_id'] == array_search('Refunded', $contributionStatus)
 154         || $params['contribution_status_id'] == array_search('Cancelled', $contributionStatus))
 155       ) {
 156         if (empty($params['creditnote_id']) || $params['creditnote_id'] == "null") {
 157           $params['creditnote_id'] = self::createCreditNoteId();
 158         }
 159       }
 160     }
 161     else {
 162       // Since the fee amount is expecting this (later on) ensure it is always set.
 163       // It would only not be set for an update where it is unchanged.
 164       $params['contribution_status_id'] = civicrm_api3('Contribution', 'getvalue', array('id' => $contributionID, 'return' => 'contribution_status_id'));
 165     }
 166
 167     if (!$contributionID
 168       && CRM_Utils_Array::value('membership_id', $params)
 169       && self::checkContributeSettings('deferred_revenue_enabled')
 170     ) {
 171       $memberStartDate = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_Membership', $params['membership_id'], 'start_date');
 172       if ($memberStartDate) {
 173         $params['revenue_recognition_date'] = date('Ymd', strtotime($memberStartDate));
 174       }
 175     }
 176     self::calculateMissingAmountParams($params, $contributionID);
 177
 178     if (!empty($params['payment_instrument_id'])) {
 179       $paymentInstruments = CRM_Contribute_PseudoConstant::paymentInstrument('name');
 180       if ($params['payment_instrument_id'] != array_search('Check', $paymentInstruments)) {
 181         $params['check_number'] = 'null';
 182       }
 183     }
 184
 185     $setPrevContribution = TRUE;
 186     // CRM-13964 partial payment
 187     if (!empty($params['partial_payment_total']) && !empty($params['partial_amount_to_pay'])) {
 188       $partialAmtTotal = $params['partial_payment_total'];
 189       $partialAmtPay = $params['partial_amount_to_pay'];
 190       $params['total_amount'] = $partialAmtTotal;
 191       if ($partialAmtPay < $partialAmtTotal) {
 192         $params['contribution_status_id'] = CRM_Core_PseudoConstant::getKey('CRM_Contribute_BAO_Contribution', 'contribution_status_id', 'Partially paid');
 193         $params['is_pay_later'] = 0;
 194         $setPrevContribution = FALSE;
 195       }
 196     }
 197     if ($contributionID && $setPrevContribution) {
 198       $params['prevContribution'] = self::getOriginalContribution($contributionID);
 199     }
 200
 201     if ($contributionID && !empty($params['revenue_recognition_date']) && !empty($params['prevContribution'])
 202       && !($contributionStatus[$params['prevContribution']->contribution_status_id] == 'Pending')
 203       && !self::allowUpdateRevenueRecognitionDate($contributionID)
 204     ) {
 205       unset($params['revenue_recognition_date']);
 206     }
 207
 208     if (!isset($params['tax_amount']) && $setPrevContribution && (isset($params['total_amount']) ||
 209      isset($params['financial_type_id']))) {
 210       $params = CRM_Contribute_BAO_Contribution::checkTaxAmount($params);
 211     }
 212
 213     if ($contributionID) {
 214       CRM_Utils_Hook::pre('edit', 'Contribution', $contributionID, $params);
 215     }
 216     else {
 217       CRM_Utils_Hook::pre('create', 'Contribution', NULL, $params);
 218     }
 219     $contribution = new CRM_Contribute_BAO_Contribution();
 220     $contribution->copyValues($params);
 221
 222     $contribution->id = $contributionID;
 223
 224     if (empty($contribution->id)) {
 225       // (only) on 'create', make sure that a valid currency is set (CRM-16845)
 226       if (!CRM_Utils_Rule::currencyCode($contribution->currency)) {
 227         $contribution->currency = CRM_Core_Config::singleton()->defaultCurrency;
 228       }
 229     }
 230
 231     $result = $contribution->save();
 232
 233     // Add financial_trxn details as part of fix for CRM-4724
 234     $contribution->trxn_result_code = CRM_Utils_Array::value('trxn_result_code', $params);
 235     $contribution->payment_processor = CRM_Utils_Array::value('payment_processor', $params);
 236
 237     //add Account details
 238     $params['contribution'] = $contribution;
 239     self::recordFinancialAccounts($params);
 240
 241     if (self::isUpdateToRecurringContribution($params)) {
 242       CRM_Contribute_BAO_ContributionRecur::updateOnNewPayment(
 243         (!empty($params['contribution_recur_id']) ? $params['contribution_recur_id'] : $params['prevContribution']->contribution_recur_id),
 244         $contributionStatus[$params['contribution_status_id']],
 245         CRM_Utils_Array::value('receive_date', $params)
 246       );
 247     }
 248
 249     CRM_Contact_BAO_GroupContactCache::opportunisticCacheFlush();
 250
 251     if ($contributionID) {
 252       CRM_Utils_Hook::post('edit', 'Contribution', $contribution->id, $contribution);
 253     }
 254     else {
 255       CRM_Utils_Hook::post('create', 'Contribution', $contribution->id, $contribution);
 256     }
 257
 258     return $result;
 259   }
 260
 261   /**
 262    * Is this contribution updating an existing recurring contribution.
 263    *
 264    * We need to upd the status of the linked recurring contribution if we have a new payment against it, or the initial
 265    * pending payment is being confirmed (or failing).
 266    *
 267    * @param array $params
 268    *
 269    * @return bool
 270    */
 271   public static function isUpdateToRecurringContribution($params) {
 272     if (!empty($params['contribution_recur_id']) && empty($params['id'])) {
 273       return TRUE;
 274     }
 275     if (empty($params['prevContribution']) || empty($params['contribution_status_id'])) {
 276       return FALSE;
 277     }
 278     if (empty($params['contribution_recur_id']) && empty($params['prevContribution']->contribution_recur_id)) {
 279       return FALSE;
 280     }
 281     $contributionStatus = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
 282     if ($params['prevContribution']->contribution_status_id == array_search('Pending', $contributionStatus)) {
 283       return TRUE;
 284     }
 285     return FALSE;
 286   }
 287
 288   /**
 289    * Get defaults for new entity.
 290    * @return array
 291    */
 292   public static function getDefaults() {
 293     return array(
 294       'payment_instrument_id' => key(CRM_Core_OptionGroup::values('payment_instrument',
 295           FALSE, FALSE, FALSE, 'AND is_default = 1')
 296       ),
 297       'contribution_status_id' => CRM_Core_Pseudoconstant::getKey('CRM_Contribute_BAO_Contribution', 'contribution_status_id', 'Completed'),
 298     );
 299   }
 300
 301   /**
 302    * Fetch the object and store the values in the values array.
 303    *
 304    * @param array $params
 305    *   Input parameters to find object.
 306    * @param array $values
 307    *   Output values of the object.
 308    * @param array $ids
 309    *   The array that holds all the db ids.
 310    *
 311    * @return CRM_Contribute_BAO_Contribution|null
 312    *   The found object or null
 313    */
 314   public static function getValues($params, &$values, &$ids) {
 315     if (empty($params)) {
 316       return NULL;
 317     }
 318     $contribution = new CRM_Contribute_BAO_Contribution();
 319
 320     $contribution->copyValues($params);
 321
 322     if ($contribution->find(TRUE)) {
 323       $ids['contribution'] = $contribution->id;
 324
 325       CRM_Core_DAO::storeValues($contribution, $values);
 326
 327       return $contribution;
 328     }
 329     $null = NULL; // return by reference
 330     return $null;
 331   }
 332
 333   /**
 334    * Get the values and resolve the most common mappings.
 335    *
 336    * Since contribution status is resolved in almost every function that calls getValues it makes
 337    * sense to have an extra function to resolve it rather than repeat the code.
 338    *
 339    * Think carefully before adding more mappings to be resolved as there could be performance implications
 340    * if this function starts to be called from more iterative functions.
 341    *
 342    * @param array $params
 343    *   Input parameters to find object.
 344    *
 345    * @return array
 346    *   Array of the found contribution.
 347    * @throws CRM_Core_Exception
 348    */
 349   public static function getValuesWithMappings($params) {
 350     $values = $ids = array();
 351     $contribution = self::getValues($params, $values, $ids);
 352     if (is_null($contribution)) {
 353       throw new CRM_Core_Exception('No contribution found');
 354     }
 355     $values['contribution_status'] = CRM_Core_PseudoConstant::getName('CRM_Contribute_BAO_Contribution', 'contribution_status_id', $values['contribution_status_id']);
 356     return $values;
 357   }
 358
 359   /**
 360    * Calculate net_amount & fee_amount if they are not set.
 361    *
 362    * Net amount should be total - fee.
 363    * This should only be called for new contributions.
 364    *
 365    * @param array $params
 366    *   Params for a new contribution before they are saved.
 367    * @param int|null $contributionID
 368    *   Contribution ID if we are dealing with an update.
 369    *
 370    * @throws \CiviCRM_API3_Exception
 371    */
 372   public static function calculateMissingAmountParams(&$params, $contributionID) {
 373     if (!$contributionID && !isset($params['fee_amount'])) {
 374       if (isset($params['total_amount']) && isset($params['net_amount'])) {
 375         $params['fee_amount'] = $params['total_amount'] - $params['net_amount'];
 376       }
 377       else {
 378         $params['fee_amount'] = 0;
 379       }
 380     }
 381     if (!isset($params['net_amount'])) {
 382       if (!$contributionID) {
 383         $params['net_amount'] = $params['total_amount'] - $params['fee_amount'];
 384       }
 385       else {
 386         if (isset($params['fee_amount']) || isset($params['total_amount'])) {
 387           // We have an existing contribution and fee_amount or total_amount has been passed in but not net_amount.
 388           // net_amount may need adjusting.
 389           $contribution = civicrm_api3('Contribution', 'getsingle', array(
 390             'id' => $contributionID,
 391             'return' => array('total_amount', 'net_amount', 'fee_amount'),
 392           ));
 393           $totalAmount = isset($params['total_amount']) ? $params['total_amount'] : CRM_Utils_Array::value('total_amount', $contribution);
 394           $feeAmount = isset($params['fee_amount']) ? $params['fee_amount'] : CRM_Utils_Array::value('fee_amount', $contribution);
 395           $params['net_amount'] = $totalAmount - $feeAmount;
 396         }
 397       }
 398     }
 399   }
 400
 401   /**
 402    * @param $params
 403    * @param $billingLocationTypeID
 404    *
 405    * @return array
 406    */
 407   protected static function getBillingAddressParams($params, $billingLocationTypeID) {
 408     $hasBillingField = FALSE;
 409     $billingFields = array(
 410       'street_address',
 411       'city',
 412       'state_province_id',
 413       'postal_code',
 414       'country_id',
 415     );
 416
 417     //build address array
 418     $addressParams = array();
 419     $addressParams['location_type_id'] = $billingLocationTypeID;
 420     $addressParams['is_billing'] = 1;
 421
 422     $billingFirstName = CRM_Utils_Array::value('billing_first_name', $params);
 423     $billingMiddleName = CRM_Utils_Array::value('billing_middle_name', $params);
 424     $billingLastName = CRM_Utils_Array::value('billing_last_name', $params);
 425     $addressParams['address_name'] = "{$billingFirstName}" . CRM_Core_DAO::VALUE_SEPARATOR . "{$billingMiddleName}" . CRM_Core_DAO::VALUE_SEPARATOR . "{$billingLastName}";
 426
 427     foreach ($billingFields as $value) {
 428       $addressParams[$value] = CRM_Utils_Array::value("billing_{$value}-{$billingLocationTypeID}", $params);
 429       if (!empty($addressParams[$value])) {
 430         $hasBillingField = TRUE;
 431       }
 432     }
 433     return array($hasBillingField, $addressParams);
 434   }
 435
 436   /**
 437    * Get address params ready to be passed to the payment processor.
 438    *
 439    * We need address params in a couple of formats. For the payment processor we wan state_province_id-5.
 440    * To create an address we need state_province_id.
 441    *
 442    * @param array $params
 443    * @param int $billingLocationTypeID
 444    *
 445    * @return array
 446    */
 447   public static function getPaymentProcessorReadyAddressParams($params, $billingLocationTypeID) {
 448     list($hasBillingField, $addressParams) = self::getBillingAddressParams($params, $billingLocationTypeID);
 449     foreach ($addressParams as $name => $field) {
 450       if (substr($name, 0, 8) == 'billing_') {
 451         $addressParams[substr($name, 9)] = $addressParams[$field];
 452       }
 453     }
 454     return array($hasBillingField, $addressParams);
 455   }
 456
 457   /**
 458    * Get the number of terms for this contribution for a given membership type
 459    * based on querying the line item table and relevant price field values
 460    * Note that any one contribution should only be able to have one line item relating to a particular membership
 461    * type
 462    *
 463    * @param int $membershipTypeID
 464    *
 465    * @param int $contributionID
 466    *
 467    * @return int
 468    */
 469   public function getNumTermsByContributionAndMembershipType($membershipTypeID, $contributionID) {
 470     $numTerms = CRM_Core_DAO::singleValueQuery("
 471       SELECT membership_num_terms FROM civicrm_line_item li
 472       LEFT JOIN civicrm_price_field_value v ON li.price_field_value_id = v.id
 473       WHERE contribution_id = %1 AND membership_type_id = %2",
 474       array(1 => array($contributionID, 'Integer'), 2 => array($membershipTypeID, 'Integer'))
 475     );
 476     // default of 1 is precautionary
 477     return empty($numTerms) ? 1 : $numTerms;
 478   }
 479
 480   /**
 481    * Takes an associative array and creates a contribution object.
 482    *
 483    * @param array $params
 484    *   (reference ) an assoc array of name/value pairs.
 485    * @param array $ids
 486    *   The array that holds all the db ids.
 487    *
 488    * @return CRM_Contribute_BAO_Contribution
 489    */
 490   public static function create(&$params, $ids = array()) {
 491     $dateFields = array('receive_date', 'cancel_date', 'receipt_date', 'thankyou_date', 'revenue_recognition_date');
 492     foreach ($dateFields as $df) {
 493       if (isset($params[$df])) {
 494         $params[$df] = CRM_Utils_Date::isoToMysql($params[$df]);
 495       }
 496     }
 497
 498     $transaction = new CRM_Core_Transaction();
 499
 500     try {
 501       $contribution = self::add($params, $ids);
 502     }
 503     catch (CRM_Core_Exception $e) {
 504       $transaction->rollback();
 505       throw $e;
 506     }
 507
 508     $params['contribution_id'] = $contribution->id;
 509
 510     if (!empty($params['custom']) &&
 511       is_array($params['custom'])
 512     ) {
 513       CRM_Core_BAO_CustomValueTable::store($params['custom'], 'civicrm_contribution', $contribution->id);
 514     }
 515
 516     $session = CRM_Core_Session::singleton();
 517
 518     if (!empty($params['note'])) {
 519       $noteParams = array(
 520         'entity_table' => 'civicrm_contribution',
 521         'note' => $params['note'],
 522         'entity_id' => $contribution->id,
 523         'contact_id' => $session->get('userID'),
 524         'modified_date' => date('Ymd'),
 525       );
 526       if (!$noteParams['contact_id']) {
 527         $noteParams['contact_id'] = $params['contact_id'];
 528       }
 529       CRM_Core_BAO_Note::add($noteParams);
 530     }
 531
 532     // make entry in batch entity batch table
 533     if (!empty($params['batch_id'])) {
 534       // in some update cases we need to get extra fields - ie an update that doesn't pass in all these params
 535       $titleFields = array(
 536         'contact_id',
 537         'total_amount',
 538         'currency',
 539         'financial_type_id',
 540       );
 541       $retrieveRequired = 0;
 542       foreach ($titleFields as $titleField) {
 543         if (!isset($contribution->$titleField)) {
 544           $retrieveRequired = 1;
 545           break;
 546         }
 547       }
 548       if ($retrieveRequired == 1) {
 549         $contribution->find(TRUE);
 550       }
 551     }
 552
 553     CRM_Contribute_BAO_ContributionSoft::processSoftContribution($params, $contribution);
 554
 555     $transaction->commit();
 556
 557     $activity = civicrm_api3('Activity', 'get', array(
 558       'source_record_id' => $contribution->id,
 559       'options' => array('limit' => 1),
 560       'sequential' => 1,
 561       'activity_type_id' => 'Contribution',
 562       'return' => array('id', 'campaign'),
 563     ));
 564
 565     //CRM-18406: Update activity when edit contribution.
 566     if ($activity['count']) {
 567       // CRM-13237 : if activity record found, update it with campaign id of contribution
 568       // @todo compare campaign ids first.
 569       CRM_Core_DAO::setFieldValue('CRM_Activity_BAO_Activity', $activity['id'], 'campaign_id', $contribution->campaign_id);
 570       $contribution->activity_id = $activity['id'];
 571     }
 572
 573     if (empty($contribution->contact_id)) {
 574       $contribution->find(TRUE);
 575     }
 576     CRM_Activity_BAO_Activity::addActivity($contribution, 'Contribution');
 577
 578     // do not add to recent items for import, CRM-4399
 579     if (empty($params['skipRecentView'])) {
 580       $url = CRM_Utils_System::url('civicrm/contact/view/contribution',
 581         "action=view&reset=1&id={$contribution->id}&cid={$contribution->contact_id}&context=home"
 582       );
 583       // in some update cases we need to get extra fields - ie an update that doesn't pass in all these params
 584       $titleFields = array(
 585         'contact_id',
 586         'total_amount',
 587         'currency',
 588         'financial_type_id',
 589       );
 590       $retrieveRequired = 0;
 591       foreach ($titleFields as $titleField) {
 592         if (!isset($contribution->$titleField)) {
 593           $retrieveRequired = 1;
 594           break;
 595         }
 596       }
 597       if ($retrieveRequired == 1) {
 598         $contribution->find(TRUE);
 599       }
 600       $financialType = CRM_Contribute_PseudoConstant::financialType($contribution->financial_type_id);
 601       $title = CRM_Contact_BAO_Contact::displayName($contribution->contact_id) . ' - (' . CRM_Utils_Money::format($contribution->total_amount, $contribution->currency) . ' ' . ' - ' . $financialType . ')';
 602
 603       $recentOther = array();
 604       if (CRM_Core_Permission::checkActionPermission('CiviContribute', CRM_Core_Action::UPDATE)) {
 605         $recentOther['editUrl'] = CRM_Utils_System::url('civicrm/contact/view/contribution',
 606           "action=update&reset=1&id={$contribution->id}&cid={$contribution->contact_id}&context=home"
 607         );
 608       }
 609
 610       if (CRM_Core_Permission::checkActionPermission('CiviContribute', CRM_Core_Action::DELETE)) {
 611         $recentOther['deleteUrl'] = CRM_Utils_System::url('civicrm/contact/view/contribution',
 612           "action=delete&reset=1&id={$contribution->id}&cid={$contribution->contact_id}&context=home"
 613         );
 614       }
 615
 616       // add the recently created Contribution
 617       CRM_Utils_Recent::add($title,
 618         $url,
 619         $contribution->id,
 620         'Contribution',
 621         $contribution->contact_id,
 622         NULL,
 623         $recentOther
 624       );
 625     }
 626
 627     return $contribution;
 628   }
 629
 630   /**
 631    * Get the values for pseudoconstants for name->value and reverse.
 632    *
 633    * @param array $defaults
 634    *   (reference) the default values, some of which need to be resolved.
 635    * @param bool $reverse
 636    *   True if we want to resolve the values in the reverse direction (value -> name).
 637    */
 638   public static function resolveDefaults(&$defaults, $reverse = FALSE) {
 639     self::lookupValue($defaults, 'financial_type', CRM_Contribute_PseudoConstant::financialType(), $reverse);
 640     self::lookupValue($defaults, 'payment_instrument', CRM_Contribute_PseudoConstant::paymentInstrument(), $reverse);
 641     self::lookupValue($defaults, 'contribution_status', CRM_Contribute_PseudoConstant::contributionStatus(), $reverse);
 642     self::lookupValue($defaults, 'pcp', CRM_Contribute_PseudoConstant::pcPage(), $reverse);
 643   }
 644
 645   /**
 646    * Convert associative array names to values and vice-versa.
 647    *
 648    * This function is used by both the web form layer and the api. Note that
 649    * the api needs the name => value conversion, also the view layer typically
 650    * requires value => name conversion
 651    *
 652    * @param array $defaults
 653    * @param string $property
 654    * @param array $lookup
 655    * @param bool $reverse
 656    *
 657    * @return bool
 658    */
 659   public static function lookupValue(&$defaults, $property, &$lookup, $reverse) {
 660     $id = $property . '_id';
 661
 662     $src = $reverse ? $property : $id;
 663     $dst = $reverse ? $id : $property;
 664
 665     if (!array_key_exists($src, $defaults)) {
 666       return FALSE;
 667     }
 668
 669     $look = $reverse ? array_flip($lookup) : $lookup;
 670
 671     if (is_array($look)) {
 672       if (!array_key_exists($defaults[$src], $look)) {
 673         return FALSE;
 674       }
 675     }
 676     $defaults[$dst] = $look[$defaults[$src]];
 677     return TRUE;
 678   }
 679
 680   /**
 681    * Retrieve DB object based on input parameters.
 682    *
 683    * It also stores all the retrieved values in the default array.
 684    *
 685    * @param array $params
 686    *   (reference ) an assoc array of name/value pairs.
 687    * @param array $defaults
 688    *   (reference ) an assoc array to hold the name / value pairs.
 689    *                        in a hierarchical manner
 690    * @param array $ids
 691    *   (reference) the array that holds all the db ids.
 692    *
 693    * @return CRM_Contribute_BAO_Contribution
 694    */
 695   public static function retrieve(&$params, &$defaults, &$ids) {
 696     $contribution = CRM_Contribute_BAO_Contribution::getValues($params, $defaults, $ids);
 697     return $contribution;
 698   }
 699
 700   /**
 701    * Combine all the importable fields from the lower levels object.
 702    *
 703    * The ordering is important, since currently we do not have a weight
 704    * scheme. Adding weight is super important and should be done in the
 705    * next week or so, before this can be called complete.
 706    *
 707    * @param string $contactType
 708    * @param bool $status
 709    *
 710    * @return array
 711    *   array of importable Fields
 712    */
 713   public static function &importableFields($contactType = 'Individual', $status = TRUE) {
 714     if (!self::$_importableFields) {
 715       if (!self::$_importableFields) {
 716         self::$_importableFields = array();
 717       }
 718
 719       if (!$status) {
 720         $fields = array('' => array('title' => ts('- do not import -')));
 721       }
 722       else {
 723         $fields = array('' => array('title' => ts('- Contribution Fields -')));
 724       }
 725
 726       $note = CRM_Core_DAO_Note::import();
 727       $tmpFields = CRM_Contribute_DAO_Contribution::import();
 728       unset($tmpFields['option_value']);
 729       $optionFields = CRM_Core_OptionValue::getFields($mode = 'contribute');
 730       $contactFields = CRM_Contact_BAO_Contact::importableFields($contactType, NULL);
 731
 732       // Using new Dedupe rule.
 733       $ruleParams = array(
 734         'contact_type' => $contactType,
 735         'used' => 'Unsupervised',
 736       );
 737       $fieldsArray = CRM_Dedupe_BAO_Rule::dedupeRuleFields($ruleParams);
 738       $tmpContactField = array();
 739       if (is_array($fieldsArray)) {
 740         foreach ($fieldsArray as $value) {
 741           //skip if there is no dupe rule
 742           if ($value == 'none') {
 743             continue;
 744           }
 745           $customFieldId = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomField',
 746             $value,
 747             'id',
 748             'column_name'
 749           );
 750           $value = $customFieldId ? 'custom_' . $customFieldId : $value;
 751           $tmpContactField[trim($value)] = $contactFields[trim($value)];
 752           if (!$status) {
 753             $title = $tmpContactField[trim($value)]['title'] . ' ' . ts('(match to contact)');
 754           }
 755           else {
 756             $title = $tmpContactField[trim($value)]['title'];
 757           }
 758           $tmpContactField[trim($value)]['title'] = $title;
 759         }
 760       }
 761
 762       $tmpContactField['external_identifier'] = $contactFields['external_identifier'];
 763       $tmpContactField['external_identifier']['title'] = $contactFields['external_identifier']['title'] . ' ' . ts('(match to contact)');
 764       $tmpFields['contribution_contact_id']['title'] = $tmpFields['contribution_contact_id']['title'] . ' ' . ts('(match to contact)');
 765       $fields = array_merge($fields, $tmpContactField);
 766       $fields = array_merge($fields, $tmpFields);
 767       $fields = array_merge($fields, $note);
 768       $fields = array_merge($fields, $optionFields);
 769       $fields = array_merge($fields, CRM_Financial_DAO_FinancialType::export());
 770       $fields = array_merge($fields, CRM_Core_BAO_CustomField::getFieldsForImport('Contribution'));
 771       self::$_importableFields = $fields;
 772     }
 773     return self::$_importableFields;
 774   }
 775
 776   /**
 777    * Combine all the exportable fields from the lower level objects.
 778    *
 779    * @param bool $checkPermission
 780    *
 781    * @return array
 782    *   array of exportable Fields
 783    */
 784   public static function &exportableFields($checkPermission = TRUE) {
 785     if (!self::$_exportableFields) {
 786       if (!self::$_exportableFields) {
 787         self::$_exportableFields = array();
 788       }
 789
 790       $fields = CRM_Contribute_DAO_Contribution::export();
 791       if (CRM_Contribute_BAO_Query::isSiteHasProducts()) {
 792         $fields = array_merge(
 793           $fields,
 794           CRM_Contribute_DAO_Product::export(),
 795           CRM_Contribute_DAO_ContributionProduct::export(),
 796           // CRM-16713 - contribution search by Premiums on 'Find Contribution' form.
 797           [
 798             'contribution_product_id' => [
 799               'title' => ts('Premium'),
 800               'name' => 'contribution_product_id',
 801               'where' => 'civicrm_product.id',
 802               'data_type' => CRM_Utils_Type::T_INT,
 803             ],
 804           ]
 805         );
 806       }
 807
 808       $financialAccount = CRM_Financial_DAO_FinancialAccount::export();
 809
 810       $contributionPage = array(
 811         'contribution_page' => array(
 812           'title' => ts('Contribution Page'),
 813           'name' => 'contribution_page',
 814           'where' => 'civicrm_contribution_page.title',
 815           'data_type' => CRM_Utils_Type::T_STRING,
 816         ),
 817       );
 818
 819       $contributionNote = array(
 820         'contribution_note' => array(
 821           'title' => ts('Contribution Note'),
 822           'name' => 'contribution_note',
 823           'data_type' => CRM_Utils_Type::T_TEXT,
 824         ),
 825       );
 826
 827       $extraFields = array(
 828         'contribution_batch' => array(
 829           'title' => ts('Batch Name'),
 830         ),
 831       );
 832
 833       // CRM-17787
 834       $campaignTitle = array(
 835         'contribution_campaign_title' => array(
 836           'title' => ts('Campaign Title'),
 837           'name' => 'campaign_title',
 838           'where' => 'civicrm_campaign.title',
 839           'data_type' => CRM_Utils_Type::T_STRING,
 840         ),
 841       );
 842       $softCreditFields = array(
 843         'contribution_soft_credit_name' => array(
 844           'name' => 'contribution_soft_credit_name',
 845           'title' => ts('Soft Credit For'),
 846           'where' => 'civicrm_contact_d.display_name',
 847           'data_type' => CRM_Utils_Type::T_STRING,
 848         ),
 849         'contribution_soft_credit_amount' => array(
 850           'name' => 'contribution_soft_credit_amount',
 851           'title' => ts('Soft Credit Amount'),
 852           'where' => 'civicrm_contribution_soft.amount',
 853           'data_type' => CRM_Utils_Type::T_MONEY,
 854         ),
 855         'contribution_soft_credit_type' => array(
 856           'name' => 'contribution_soft_credit_type',
 857           'title' => ts('Soft Credit Type'),
 858           'where' => 'contribution_softcredit_type.label',
 859           'data_type' => CRM_Utils_Type::T_STRING,
 860         ),
 861         'contribution_soft_credit_contribution_id' => array(
 862           'name' => 'contribution_soft_credit_contribution_id',
 863           'title' => ts('Soft Credit For Contribution ID'),
 864           'where' => 'civicrm_contribution_soft.contribution_id',
 865           'data_type' => CRM_Utils_Type::T_INT,
 866         ),
 867         'contribution_soft_credit_contact_id' => array(
 868           'name' => 'contribution_soft_credit_contact_id',
 869           'title' => ts('Soft Credit For Contact ID'),
 870           'where' => 'civicrm_contact_d.id',
 871           'data_type' => CRM_Utils_Type::T_INT,
 872         ),
 873       );
 874
 875       $fields = array_merge($fields, $contributionPage,
 876         $contributionNote, $extraFields, $softCreditFields, $financialAccount, $campaignTitle,
 877         CRM_Core_BAO_CustomField::getFieldsForImport('Contribution', FALSE, FALSE, FALSE, $checkPermission)
 878       );
 879
 880       self::$_exportableFields = $fields;
 881     }
 882
 883     return self::$_exportableFields;
 884   }
 885
 886   /**
 887    * @param $contributionId
 888    * @param $participantId
 889    * @param array $financialTrxn
 890    *
 891    * @param $financialTrxn
 892    */
 893   protected static function recordPaymentActivity($contributionId, $participantId, $financialTrxn) {
 894     $activityType = ($financialTrxn->total_amount < 0) ? 'Refund' : 'Payment';
 895     if ($participantId) {
 896       $inputParams['id'] = $participantId;
 897       $values = [];
 898       $ids = [];
 899       $component = 'event';
 900       $entityObj = CRM_Event_BAO_Participant::getValues($inputParams, $values, $ids);
 901       $entityObj = $entityObj[$participantId];
 902     }
 903     else {
 904       $entityObj = new CRM_Contribute_BAO_Contribution();
 905       $entityObj->id = $contributionId;
 906       $entityObj->find(TRUE);
 907       $component = 'contribution';
 908     }
 909
 910     self::addActivityForPayment($entityObj, $financialTrxn, $activityType, $component, $contributionId);
 911   }
 912
 913   /**
 914    * Get the value for the To Financial Account.
 915    *
 916    * @param $contribution
 917    * @param $params
 918    *
 919    * @return int
 920    */
 921   protected static function getToFinancialAccount($contribution, $params) {
 922     $contributionStatuses = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
 923     CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
 924     $pendingStatus = [
 925       array_search('Pending', $contributionStatuses),
 926       array_search('In Progress', $contributionStatuses),
 927     ];
 928     if (in_array(CRM_Utils_Array::value('contribution_status_id', $contribution), $pendingStatus)) {
 929       return CRM_Contribute_PseudoConstant::getRelationalFinancialAccount($contribution['financial_type_id'], 'Accounts Receivable Account is');
 930     }
 931     elseif (!empty($params['payment_processor'])) {
 932       return CRM_Contribute_PseudoConstant::getRelationalFinancialAccount($contribution['payment_processor'], NULL, 'civicrm_payment_processor');
 933     }
 934     elseif (!empty($params['payment_instrument_id'])) {
 935       return CRM_Financial_BAO_FinancialTypeAccount::getInstrumentFinancialAccount($contribution['payment_instrument_id']);
 936     }
 937     else {
 938       $relationTypeId = key(CRM_Core_PseudoConstant::accountOptionValues('financial_account_type', NULL, " AND v.name LIKE 'Asset' "));
 939       $queryParams = [1 => [$relationTypeId, 'Integer']];
 940       return CRM_Core_DAO::singleValueQuery("SELECT id FROM civicrm_financial_account WHERE is_default = 1 AND financial_account_type_id = %1", $queryParams);
 941     }
 942   }
 943
 944   /**
 945    * Get memberships realted to the contribution.
 946    *
 947    * @param int $contributionID
 948    *
 949    * @return array
 950    */
 951   protected static function getRelatedMemberships($contributionID) {
 952     $membershipPayments = civicrm_api3('MembershipPayment', 'get', [
 953       'return' => 'membership_id',
 954       'contribution_id' => (int) $contributionID,
 955     ])['values'];
 956     $membershipIDs = [];
 957     foreach ($membershipPayments as $membershipPayment) {
 958       $membershipIDs[] = $membershipPayment['membership_id'];
 959     }
 960     if (empty($membershipIDs)) {
 961       return [];
 962     }
 963     // We could combine this with the MembershipPayment.get - we'd
 964     // need to re-wrangle the params (here or in the calling function)
 965     // as they would then me membership.contact_id, membership.is_test etc
 966     return civicrm_api3('Membership', 'get', [
 967       'id' => ['IN' => $membershipIDs],
 968       'return' => ['id', 'contact_id', 'membership_type_id', 'is_test']
 969     ])['values'];
 970   }
 971
 972   /**
 973    * @inheritDoc
 974    */
 975   public function addSelectWhereClause() {
 976     $whereClauses = parent::addSelectWhereClause();
 977     if ($whereClauses !== []) {
 978       // In this case permisssions have been applied & we assume the
 979       // financialaclreport is applying these
 980       // https://github.com/JMAConsulting/biz.jmaconsulting.financialaclreport/blob/master/financialaclreport.php#L107
 981       return $whereClauses;
 982     }
 983
 984     if (!CRM_Financial_BAO_FinancialType::isACLFinancialTypeStatus()) {
 985       return $whereClauses;
 986     }
 987     $types = CRM_Financial_BAO_FinancialType::getAllEnabledAvailableFinancialTypes();
 988     if (empty($types)) {
 989       $whereClauses['financial_type_id'] = 'IN (0)';
 990     }
 991     else {
 992       $whereClauses['financial_type_id'] = [
 993         'IN (' . implode(',', array_keys($types)) . ')'
 994       ];
 995     }
 996     return $whereClauses;
 997   }
 998
 999   /**
1000    * @param null $status
1001    * @param null $startDate
1002    * @param null $endDate
1003    *
1004    * @return array|null
1005    */
1006   public static function getTotalAmountAndCount($status = NULL, $startDate = NULL, $endDate = NULL) {
1007     $where = array();
1008     switch ($status) {
1009       case 'Valid':
1010         $where[] = 'contribution_status_id = 1';
1011         break;
1012
1013       case 'Cancelled':
1014         $where[] = 'contribution_status_id = 3';
1015         break;
1016     }
1017
1018     if ($startDate) {
1019       $where[] = "receive_date >= '" . CRM_Utils_Type::escape($startDate, 'Timestamp') . "'";
1020     }
1021     if ($endDate) {
1022       $where[] = "receive_date <= '" . CRM_Utils_Type::escape($endDate, 'Timestamp') . "'";
1023     }
1024     $financialTypeACLJoin = '';
1025     if (CRM_Financial_BAO_FinancialType::isACLFinancialTypeStatus()) {
1026       $financialTypeACLJoin = " LEFT JOIN civicrm_line_item i ON (i.contribution_id = c.id AND i.entity_table = 'civicrm_contribution') ";
1027       $financialTypes = CRM_Contribute_PseudoConstant::financialType();
1028       CRM_Financial_BAO_FinancialType::getAvailableFinancialTypes($financialTypes);
1029       if ($financialTypes) {
1030         $where[] = "c.financial_type_id IN (" . implode(',', array_keys($financialTypes)) . ")";
1031         $where[] = "i.financial_type_id IN (" . implode(',', array_keys($financialTypes)) . ")";
1032       }
1033       else {
1034         $where[] = "c.financial_type_id IN (0)";
1035       }
1036     }
1037
1038     $whereCond = implode(' AND ', $where);
1039
1040     $query = "
1041     SELECT  sum( total_amount ) as total_amount,
1042             count( c.id ) as total_count,
1043             currency
1044       FROM  civicrm_contribution c
1045 INNER JOIN  civicrm_contact contact ON ( contact.id = c.contact_id )
1046      $financialTypeACLJoin
1047      WHERE  $whereCond
1048        AND  ( is_test = 0 OR is_test IS NULL )
1049        AND  contact.is_deleted = 0
1050   GROUP BY  currency
1051 ";
1052
1053     $dao = CRM_Core_DAO::executeQuery($query);
1054     $amount = array();
1055     $count = 0;
1056     while ($dao->fetch()) {
1057       $count += $dao->total_count;
1058       $amount[] = CRM_Utils_Money::format($dao->total_amount, $dao->currency);
1059     }
1060     if ($count) {
1061       return array(
1062         'amount' => implode(', ', $amount),
1063         'count' => $count,
1064       );
1065     }
1066     return NULL;
1067   }
1068
1069   /**
1070    * Delete the indirect records associated with this contribution first.
1071    *
1072    * @param int $id
1073    *
1074    * @return mixed|null
1075    *   $results no of deleted Contribution on success, false otherwise
1076    */
1077   public static function deleteContribution($id) {
1078     CRM_Utils_Hook::pre('delete', 'Contribution', $id, CRM_Core_DAO::$_nullArray);
1079
1080     $transaction = new CRM_Core_Transaction();
1081
1082     $results = NULL;
1083     //delete activity record
1084     $params = array(
1085       'source_record_id' => $id,
1086       // activity type id for contribution
1087       'activity_type_id' => 6,
1088     );
1089
1090     CRM_Activity_BAO_Activity::deleteActivity($params);
1091
1092     //delete billing address if exists for this contribution.
1093     self::deleteAddress($id);
1094
1095     //update pledge and pledge payment, CRM-3961
1096     CRM_Pledge_BAO_PledgePayment::resetPledgePayment($id);
1097
1098     // remove entry from civicrm_price_set_entity, CRM-5095
1099     if (CRM_Price_BAO_PriceSet::getFor('civicrm_contribution', $id)) {
1100       CRM_Price_BAO_PriceSet::removeFrom('civicrm_contribution', $id);
1101     }
1102     // cleanup line items.
1103     $participantId = CRM_Core_DAO::getFieldValue('CRM_Event_DAO_ParticipantPayment', $id, 'participant_id', 'contribution_id');
1104
1105     // delete any related entity_financial_trxn, financial_trxn and financial_item records.
1106     CRM_Core_BAO_FinancialTrxn::deleteFinancialTrxn($id);
1107
1108     if ($participantId) {
1109       CRM_Price_BAO_LineItem::deleteLineItems($participantId, 'civicrm_participant');
1110     }
1111     else {
1112       CRM_Price_BAO_LineItem::deleteLineItems($id, 'civicrm_contribution');
1113     }
1114
1115     //delete note.
1116     $note = CRM_Core_BAO_Note::getNote($id, 'civicrm_contribution');
1117     $noteId = key($note);
1118     if ($noteId) {
1119       CRM_Core_BAO_Note::del($noteId, FALSE);
1120     }
1121
1122     $dao = new CRM_Contribute_DAO_Contribution();
1123     $dao->id = $id;
1124
1125     $results = $dao->delete();
1126
1127     $transaction->commit();
1128
1129     CRM_Utils_Hook::post('delete', 'Contribution', $dao->id, $dao);
1130
1131     // delete the recently created Contribution
1132     $contributionRecent = array(
1133       'id' => $id,
1134       'type' => 'Contribution',
1135     );
1136     CRM_Utils_Recent::del($contributionRecent);
1137
1138     return $results;
1139   }
1140
1141   /**
1142    * React to a financial transaction (payment) failure.
1143    *
1144    * Prior to CRM-16417 these were simply removed from the database but it has been agreed that seeing attempted
1145    * payments is important for forensic and outreach reasons.
1146    *
1147    * @param int $contributionID
1148    * @param int $contactID
1149    * @param string $message
1150    *
1151    * @throws \CiviCRM_API3_Exception
1152    */
1153   public static function failPayment($contributionID, $contactID, $message) {
1154     civicrm_api3('activity', 'create', array(
1155       'activity_type_id' => 'Failed Payment',
1156       'details' => $message,
1157       'subject' => ts('Payment failed at payment processor'),
1158       'source_record_id' => $contributionID,
1159       'source_contact_id' => CRM_Core_Session::getLoggedInContactID() ? CRM_Core_Session::getLoggedInContactID() :
1160         $contactID,
1161     ));
1162
1163     // CRM-20336 Make sure that the contribution status is Failed, not Pending.
1164     civicrm_api3('contribution', 'create', array(
1165       'id' => $contributionID,
1166       'contribution_status_id' => 'Failed',
1167     ));
1168   }
1169
1170   /**
1171    * Check if there is a contribution with the same trxn_id or invoice_id.
1172    *
1173    * @param array $input
1174    *   An assoc array of name/value pairs.
1175    * @param array $duplicates
1176    *   (reference) store ids of duplicate contribs.
1177    * @param int $id
1178    *
1179    * @return bool
1180    *   true if duplicate, false otherwise
1181    */
1182   public static function checkDuplicate($input, &$duplicates, $id = NULL) {
1183     if (!$id) {
1184       $id = CRM_Utils_Array::value('id', $input);
1185     }
1186     $trxn_id = CRM_Utils_Array::value('trxn_id', $input);
1187     $invoice_id = CRM_Utils_Array::value('invoice_id', $input);
1188
1189     $clause = array();
1190     $input = array();
1191
1192     if ($trxn_id) {
1193       $clause[] = "trxn_id = %1";
1194       $input[1] = array($trxn_id, 'String');
1195     }
1196
1197     if ($invoice_id) {
1198       $clause[] = "invoice_id = %2";
1199       $input[2] = array($invoice_id, 'String');
1200     }
1201
1202     if (empty($clause)) {
1203       return FALSE;
1204     }
1205
1206     $clause = implode(' OR ', $clause);
1207     if ($id) {
1208       $clause = "( $clause ) AND id != %3";
1209       $input[3] = array($id, 'Integer');
1210     }
1211
1212     $query = "SELECT id FROM civicrm_contribution WHERE $clause";
1213     $dao = CRM_Core_DAO::executeQuery($query, $input);
1214     $result = FALSE;
1215     while ($dao->fetch()) {
1216       $duplicates[] = $dao->id;
1217       $result = TRUE;
1218     }
1219     return $result;
1220   }
1221
1222   /**
1223    * Takes an associative array and creates a contribution_product object.
1224    *
1225    * the function extract all the params it needs to initialize the create a
1226    * contribution_product object. the params array could contain additional unused name/value
1227    * pairs
1228    *
1229    * @param array $params
1230    *   (reference) an assoc array of name/value pairs.
1231    *
1232    * @return CRM_Contribute_DAO_ContributionProduct
1233    */
1234   public static function addPremium(&$params) {
1235     $contributionProduct = new CRM_Contribute_DAO_ContributionProduct();
1236     $contributionProduct->copyValues($params);
1237     return $contributionProduct->save();
1238   }
1239
1240   /**
1241    * Get list of contribution fields for profile.
1242    * For now we only allow custom contribution fields to be in
1243    * profile
1244    *
1245    * @param bool $addExtraFields
1246    *   True if special fields needs to be added.
1247    *
1248    * @return array
1249    *   the list of contribution fields
1250    */
1251   public static function getContributionFields($addExtraFields = TRUE) {
1252     $contributionFields = CRM_Contribute_DAO_Contribution::export();
1253     // @todo remove this - this line was added because payment_instrument_id was not
1254     // set to exportable - but now it is.
1255     $contributionFields = array_merge($contributionFields, CRM_Core_OptionValue::getFields($mode = 'contribute'));
1256
1257     if ($addExtraFields) {
1258       $contributionFields = array_merge($contributionFields, self::getSpecialContributionFields());
1259     }
1260
1261     $contributionFields = array_merge($contributionFields, CRM_Financial_DAO_FinancialType::export());
1262
1263     foreach ($contributionFields as $key => $var) {
1264       if ($key == 'contribution_contact_id') {
1265         continue;
1266       }
1267       elseif ($key == 'contribution_campaign_id') {
1268         $var['title'] = ts('Campaign');
1269       }
1270       $fields[$key] = $var;
1271     }
1272
1273     $fields = array_merge($fields, CRM_Core_BAO_CustomField::getFieldsForImport('Contribution'));
1274     return $fields;
1275   }
1276
1277   /**
1278    * Add extra fields specific to contribution.
1279    */
1280   public static function getSpecialContributionFields() {
1281     $extraFields = array(
1282       'contribution_soft_credit_name' => array(
1283         'name' => 'contribution_soft_credit_name',
1284         'title' => ts('Soft Credit Name'),
1285         'headerPattern' => '/^soft_credit_name$/i',
1286         'where' => 'civicrm_contact_d.display_name',
1287       ),
1288       'contribution_soft_credit_email' => array(
1289         'name' => 'contribution_soft_credit_email',
1290         'title' => ts('Soft Credit Email'),
1291         'headerPattern' => '/^soft_credit_email$/i',
1292         'where' => 'soft_email.email',
1293       ),
1294       'contribution_soft_credit_phone' => array(
1295         'name' => 'contribution_soft_credit_phone',
1296         'title' => ts('Soft Credit Phone'),
1297         'headerPattern' => '/^soft_credit_phone$/i',
1298         'where' => 'soft_phone.phone',
1299       ),
1300       'contribution_soft_credit_contact_id' => array(
1301         'name' => 'contribution_soft_credit_contact_id',
1302         'title' => ts('Soft Credit Contact ID'),
1303         'headerPattern' => '/^soft_credit_contact_id$/i',
1304         'where' => 'civicrm_contribution_soft.contact_id',
1305       ),
1306       'contribution_pcp_title' => array(
1307         'name' => 'contribution_pcp_title',
1308         'title' => ts('Personal Campaign Page Title'),
1309         'headerPattern' => '/^contribution_pcp_title$/i',
1310         'where' => 'contribution_pcp.title',
1311       ),
1312     );
1313
1314     return $extraFields;
1315   }
1316
1317   /**
1318    * @param int $pageID
1319    *
1320    * @return array
1321    */
1322   public static function getCurrentandGoalAmount($pageID) {
1323     $query = "
1324 SELECT p.goal_amount as goal, sum( c.total_amount ) as total
1325   FROM civicrm_contribution_page p,
1326        civicrm_contribution      c
1327  WHERE p.id = c.contribution_page_id
1328    AND p.id = %1
1329    AND c.cancel_date is null
1330 GROUP BY p.id
1331 ";
1332
1333     $config = CRM_Core_Config::singleton();
1334     $params = array(1 => array($pageID, 'Integer'));
1335     $dao = CRM_Core_DAO::executeQuery($query, $params);
1336
1337     if ($dao->fetch()) {
1338       return array($dao->goal, $dao->total);
1339     }
1340     else {
1341       return array(NULL, NULL);
1342     }
1343   }
1344
1345   /**
1346    * Get list of contributions which credit the passed in contact ID.
1347    *
1348    * The returned array provides details about the original contribution & donor.
1349    *
1350    * @todo - this is a confusing function called from one place. It has a test. It would be
1351    * nice to deprecate it.
1352    *
1353    * @param int $honorId
1354    *   In Honor of Contact ID.
1355    *
1356    * @return array
1357    *   list of contribution fields
1358    */
1359   public static function getHonorContacts($honorId) {
1360     $params = array();
1361     $honorDAO = new CRM_Contribute_DAO_ContributionSoft();
1362     $honorDAO->contact_id = $honorId;
1363     $honorDAO->find();
1364
1365     $type = CRM_Contribute_PseudoConstant::financialType();
1366
1367     while ($honorDAO->fetch()) {
1368       $contributionDAO = new CRM_Contribute_DAO_Contribution();
1369       $contributionDAO->id = $honorDAO->contribution_id;
1370
1371       if ($contributionDAO->find(TRUE)) {
1372         $params[$contributionDAO->id]['honor_type'] = CRM_Core_PseudoConstant::getLabel('CRM_Contribute_BAO_ContributionSoft', 'soft_credit_type_id', $honorDAO->soft_credit_type_id);
1373         $params[$contributionDAO->id]['honorId'] = $contributionDAO->contact_id;
1374         $params[$contributionDAO->id]['display_name'] = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $contributionDAO->contact_id, 'display_name');
1375         $params[$contributionDAO->id]['type'] = $type[$contributionDAO->financial_type_id];
1376         $params[$contributionDAO->id]['type_id'] = $contributionDAO->financial_type_id;
1377         $params[$contributionDAO->id]['amount'] = CRM_Utils_Money::format($contributionDAO->total_amount, $contributionDAO->currency);
1378         $params[$contributionDAO->id]['source'] = $contributionDAO->source;
1379         $params[$contributionDAO->id]['receive_date'] = $contributionDAO->receive_date;
1380         $params[$contributionDAO->id]['contribution_status'] = CRM_Contribute_PseudoConstant::contributionStatus($contributionDAO->contribution_status_id);
1381       }
1382     }
1383
1384     return $params;
1385   }
1386
1387   /**
1388    * Get the sort name of a contact for a particular contribution.
1389    *
1390    * @param int $id
1391    *   Id of the contribution.
1392    *
1393    * @return null|string
1394    *   sort name of the contact if found
1395    */
1396   public static function sortName($id) {
1397     $id = CRM_Utils_Type::escape($id, 'Integer');
1398
1399     $query = "
1400 SELECT civicrm_contact.sort_name
1401 FROM   civicrm_contribution, civicrm_contact
1402 WHERE  civicrm_contribution.contact_id = civicrm_contact.id
1403   AND  civicrm_contribution.id = {$id}
1404 ";
1405     return CRM_Core_DAO::singleValueQuery($query);
1406   }
1407
1408   /**
1409    * Generate summary of amount received in the current fiscal year to date from the contact or contacts.
1410    *
1411    * @param int|array $contactIDs
1412    *
1413    * @return array
1414    */
1415   public static function annual($contactIDs) {
1416     if (!is_array($contactIDs)) {
1417       // In practice I can't fine any evidence that this function is ever called with
1418       // anything other than a single contact id, but left like this due to .... fear.
1419       $contactIDs = explode(',', $contactIDs);
1420     }
1421
1422     $query = self::getAnnualQuery($contactIDs);
1423     $dao = CRM_Core_DAO::executeQuery($query);
1424     $count = 0;
1425     $amount = $average = array();
1426     while ($dao->fetch()) {
1427       if ($dao->count > 0 && $dao->amount > 0) {
1428         $count += $dao->count;
1429         $amount[] = CRM_Utils_Money::format($dao->amount, $dao->currency);
1430         $average[] = CRM_Utils_Money::format($dao->average, $dao->currency);
1431       }
1432     }
1433     if ($count > 0) {
1434       return array(
1435         $count,
1436         implode(',&nbsp;', $amount),
1437         implode(',&nbsp;', $average),
1438       );
1439     }
1440     return array(0, 0, 0);
1441   }
1442
1443   /**
1444    * Check if there is a contribution with the params passed in.
1445    *
1446    * Used for trxn_id,invoice_id and contribution_id
1447    *
1448    * @param array $params
1449    *   An assoc array of name/value pairs.
1450    *
1451    * @return array
1452    *   contribution id if success else NULL
1453    */
1454   public static function checkDuplicateIds($params) {
1455     $dao = new CRM_Contribute_DAO_Contribution();
1456
1457     $clause = array();
1458     $input = array();
1459     foreach ($params as $k => $v) {
1460       if ($v) {
1461         $clause[] = "$k = '$v'";
1462       }
1463     }
1464     $clause = implode(' AND ', $clause);
1465     $query = "SELECT id FROM civicrm_contribution WHERE $clause";
1466     $dao = CRM_Core_DAO::executeQuery($query, $input);
1467
1468     while ($dao->fetch()) {
1469       $result = $dao->id;
1470       return $result;
1471     }
1472     return NULL;
1473   }
1474
1475   /**
1476    * Get the contribution details for component export.
1477    *
1478    * @param int $exportMode
1479    *   Export mode.
1480    * @param array $componentIds
1481    *   Component ids.
1482    *
1483    * @return array
1484    *   associated array
1485    */
1486   public static function getContributionDetails($exportMode, $componentIds) {
1487     $paymentDetails = array();
1488     $componentClause = ' IN ( ' . implode(',', $componentIds) . ' ) ';
1489
1490     if ($exportMode == CRM_Export_Form_Select::EVENT_EXPORT) {
1491       $componentSelect = " civicrm_participant_payment.participant_id id";
1492       $additionalClause = "
1493 INNER JOIN civicrm_participant_payment ON (civicrm_contribution.id = civicrm_participant_payment.contribution_id
1494 AND civicrm_participant_payment.participant_id {$componentClause} )
1495 ";
1496     }
1497     elseif ($exportMode == CRM_Export_Form_Select::MEMBER_EXPORT) {
1498       $componentSelect = " civicrm_membership_payment.membership_id id";
1499       $additionalClause = "
1500 INNER JOIN civicrm_membership_payment ON (civicrm_contribution.id = civicrm_membership_payment.contribution_id
1501 AND civicrm_membership_payment.membership_id {$componentClause} )
1502 ";
1503     }
1504     elseif ($exportMode == CRM_Export_Form_Select::PLEDGE_EXPORT) {
1505       $componentSelect = " civicrm_pledge_payment.id id";
1506       $additionalClause = "
1507 INNER JOIN civicrm_pledge_payment ON (civicrm_contribution.id = civicrm_pledge_payment.contribution_id
1508 AND civicrm_pledge_payment.pledge_id {$componentClause} )
1509 ";
1510     }
1511
1512     $query = " SELECT total_amount, contribution_status.name as status_id, contribution_status.label as status, payment_instrument.name as payment_instrument, receive_date,
1513                           trxn_id, {$componentSelect}
1514 FROM civicrm_contribution
1515 LEFT JOIN civicrm_option_group option_group_payment_instrument ON ( option_group_payment_instrument.name = 'payment_instrument')
1516 LEFT JOIN civicrm_option_value payment_instrument ON (civicrm_contribution.payment_instrument_id = payment_instrument.value
1517      AND option_group_payment_instrument.id = payment_instrument.option_group_id )
1518 LEFT JOIN civicrm_option_group option_group_contribution_status ON (option_group_contribution_status.name = 'contribution_status')
1519 LEFT JOIN civicrm_option_value contribution_status ON (civicrm_contribution.contribution_status_id = contribution_status.value
1520                                AND option_group_contribution_status.id = contribution_status.option_group_id )
1521 {$additionalClause}
1522 ";
1523
1524     $dao = CRM_Core_DAO::executeQuery($query);
1525
1526     while ($dao->fetch()) {
1527       $paymentDetails[$dao->id] = array(
1528         'total_amount' => $dao->total_amount,
1529         'contribution_status' => $dao->status,
1530         'receive_date' => $dao->receive_date,
1531         'pay_instru' => $dao->payment_instrument,
1532         'trxn_id' => $dao->trxn_id,
1533       );
1534     }
1535
1536     return $paymentDetails;
1537   }
1538
1539   /**
1540    * Create address associated with contribution record.
1541    *
1542    * As long as there is one or more billing field in the parameters we will create the address.
1543    *
1544    * (historically the decision to create or not was based on the payment 'type' but these lines are greyer than once
1545    * thought).
1546    *
1547    * @param array $params
1548    * @param int $billingLocationTypeID
1549    *
1550    * @return int
1551    *   address id
1552    */
1553   public static function createAddress($params, $billingLocationTypeID) {
1554     list($hasBillingField, $addressParams) = self::getBillingAddressParams($params, $billingLocationTypeID);
1555     if ($hasBillingField) {
1556       $address = CRM_Core_BAO_Address::add($addressParams, FALSE);
1557       return $address->id;
1558     }
1559     return NULL;
1560
1561   }
1562
1563   /**
1564    * Delete billing address record related contribution.
1565    *
1566    * @param int $contributionId
1567    * @param int $contactId
1568    */
1569   public static function deleteAddress($contributionId = NULL, $contactId = NULL) {
1570     $clauses = array();
1571     $contactJoin = NULL;
1572
1573     if ($contributionId) {
1574       $clauses[] = "cc.id = {$contributionId}";
1575     }
1576
1577     if ($contactId) {
1578       $clauses[] = "cco.id = {$contactId}";
1579       $contactJoin = "INNER JOIN civicrm_contact cco ON cc.contact_id = cco.id";
1580     }
1581
1582     if (empty($clauses)) {
1583       CRM_Core_Error::fatal();
1584     }
1585
1586     $condition = implode(' OR ', $clauses);
1587
1588     $query = "
1589 SELECT     ca.id
1590 FROM       civicrm_address ca
1591 INNER JOIN civicrm_contribution cc ON cc.address_id = ca.id
1592            $contactJoin
1593 WHERE      $condition
1594 ";
1595     $dao = CRM_Core_DAO::executeQuery($query);
1596
1597     while ($dao->fetch()) {
1598       $params = array('id' => $dao->id);
1599       CRM_Core_BAO_Block::blockDelete('Address', $params);
1600     }
1601   }
1602
1603   /**
1604    * This function check online pending contribution associated w/
1605    * Online Event Registration or Online Membership signup.
1606    *
1607    * @param int $componentId
1608    *   Participant/membership id.
1609    * @param string $componentName
1610    *   Event/Membership.
1611    *
1612    * @return int
1613    *   pending contribution id.
1614    */
1615   public static function checkOnlinePendingContribution($componentId, $componentName) {
1616     $contributionId = NULL;
1617     if (!$componentId ||
1618       !in_array($componentName, array('Event', 'Membership'))
1619     ) {
1620       return $contributionId;
1621     }
1622
1623     if ($componentName == 'Event') {
1624       $idName = 'participant_id';
1625       $componentTable = 'civicrm_participant';
1626       $paymentTable = 'civicrm_participant_payment';
1627       $source = ts('Online Event Registration');
1628     }
1629
1630     if ($componentName == 'Membership') {
1631       $idName = 'membership_id';
1632       $componentTable = 'civicrm_membership';
1633       $paymentTable = 'civicrm_membership_payment';
1634       $source = ts('Online Contribution');
1635     }
1636
1637     $pendingStatusId = array_search('Pending', CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name'));
1638
1639     $query = "
1640    SELECT  component.id as {$idName},
1641            componentPayment.contribution_id as contribution_id,
1642            contribution.source source,
1643            contribution.contribution_status_id as contribution_status_id,
1644            contribution.is_pay_later as is_pay_later
1645      FROM  $componentTable component
1646 LEFT JOIN  $paymentTable componentPayment    ON ( componentPayment.{$idName} = component.id )
1647 LEFT JOIN  civicrm_contribution contribution ON ( componentPayment.contribution_id = contribution.id )
1648     WHERE  component.id = {$componentId}";
1649
1650     $dao = CRM_Core_DAO::executeQuery($query);
1651
1652     while ($dao->fetch()) {
1653       if ($dao->contribution_id &&
1654         $dao->is_pay_later &&
1655         $dao->contribution_status_id == $pendingStatusId &&
1656         strpos($dao->source, $source) !== FALSE
1657       ) {
1658         $contributionId = $dao->contribution_id;
1659       }
1660     }
1661
1662     return $contributionId;
1663   }
1664
1665   /**
1666    * Update contribution as well as related objects.
1667    *
1668    * This function by-passes hooks - to address this - don't use this function.
1669    *
1670    * @deprecated
1671    *
1672    * Use api contribute.completetransaction
1673    * For failures use failPayment (preferably exposing by api in the process).
1674    *
1675    * @param array $params
1676    * @param bool $processContributionObject
1677    *
1678    * @return array
1679    * @throws \Exception
1680    */
1681   public static function transitionComponents($params, $processContributionObject = FALSE) {
1682     // get minimum required values.
1683     $contactId = CRM_Utils_Array::value('contact_id', $params);
1684     $componentId = CRM_Utils_Array::value('component_id', $params);
1685     $componentName = CRM_Utils_Array::value('componentName', $params);
1686     $contributionId = CRM_Utils_Array::value('contribution_id', $params);
1687     $contributionStatusId = CRM_Utils_Array::value('contribution_status_id', $params);
1688
1689     // if we already processed contribution object pass previous status id.
1690     $previousContriStatusId = CRM_Utils_Array::value('previous_contribution_status_id', $params);
1691
1692     $updateResult = array();
1693
1694     $contributionStatuses = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
1695
1696     // we process only ( Completed, Cancelled, or Failed ) contributions.
1697     if (!$contributionId ||
1698       !in_array($contributionStatusId, array(
1699         array_search('Completed', $contributionStatuses),
1700         array_search('Cancelled', $contributionStatuses),
1701         array_search('Failed', $contributionStatuses),
1702       ))
1703     ) {
1704       return $updateResult;
1705     }
1706
1707     if (!$componentName || !$componentId) {
1708       // get the related component details.
1709       $componentDetails = self::getComponentDetails($contributionId);
1710     }
1711     else {
1712       $componentDetails['contact_id'] = $contactId;
1713       $componentDetails['component'] = $componentName;
1714
1715       if ($componentName == 'event') {
1716         $componentDetails['participant'] = $componentId;
1717       }
1718       else {
1719         $componentDetails['membership'] = $componentId;
1720       }
1721     }
1722
1723     if (!empty($componentDetails['contact_id'])) {
1724       $componentDetails['contact_id'] = CRM_Core_DAO::getFieldValue('CRM_Contribute_DAO_Contribution',
1725         $contributionId,
1726         'contact_id'
1727       );
1728     }
1729
1730     // do check for required ids.
1731     if (empty($componentDetails['membership']) && empty($componentDetails['participant']) && empty($componentDetails['pledge_payment']) || empty($componentDetails['contact_id'])) {
1732       return $updateResult;
1733     }
1734
1735     //now we are ready w/ required ids, start processing.
1736
1737     $baseIPN = new CRM_Core_Payment_BaseIPN();
1738
1739     $input = $ids = $objects = array();
1740
1741     $input['component'] = CRM_Utils_Array::value('component', $componentDetails);
1742     $ids['contribution'] = $contributionId;
1743     $ids['contact'] = CRM_Utils_Array::value('contact_id', $componentDetails);
1744     $ids['membership'] = CRM_Utils_Array::value('membership', $componentDetails);
1745     $ids['participant'] = CRM_Utils_Array::value('participant', $componentDetails);
1746     $ids['event'] = CRM_Utils_Array::value('event', $componentDetails);
1747     $ids['pledge_payment'] = CRM_Utils_Array::value('pledge_payment', $componentDetails);
1748     $ids['contributionRecur'] = NULL;
1749     $ids['contributionPage'] = NULL;
1750
1751     if (!$baseIPN->validateData($input, $ids, $objects, FALSE)) {
1752       CRM_Core_Error::fatal();
1753     }
1754
1755     $memberships = &$objects['membership'];
1756     $participant = &$objects['participant'];
1757     $pledgePayment = &$objects['pledge_payment'];
1758     $contribution = &$objects['contribution'];
1759
1760     if ($pledgePayment) {
1761       $pledgePaymentIDs = array();
1762       foreach ($pledgePayment as $key => $object) {
1763         $pledgePaymentIDs[] = $object->id;
1764       }
1765       $pledgeID = $pledgePayment[0]->pledge_id;
1766     }
1767
1768     $membershipStatuses = CRM_Member_PseudoConstant::membershipStatus();
1769
1770     if ($participant) {
1771       $participantStatuses = CRM_Event_PseudoConstant::participantStatus();
1772       $oldStatus = CRM_Core_DAO::getFieldValue('CRM_Event_DAO_Participant',
1773         $participant->id,
1774         'status_id'
1775       );
1776     }
1777     // we might want to process contribution object.
1778     $processContribution = FALSE;
1779     if ($contributionStatusId == array_search('Cancelled', $contributionStatuses)) {
1780       if (is_array($memberships)) {
1781         foreach ($memberships as $membership) {
1782           $update = TRUE;
1783           //Update Membership status if there is no other completed contribution associated with the membership.
1784           $relatedContributions = CRM_Member_BAO_Membership::getMembershipContributionId($membership->id, TRUE);
1785           foreach ($relatedContributions as $contriId) {
1786             if ($contriId == $contributionId) {
1787               continue;
1788             }
1789             $statusId = CRM_Core_DAO::getFieldValue('CRM_Contribute_BAO_Contribution', $contriId, 'contribution_status_id');
1790             if (CRM_Core_PseudoConstant::getName('CRM_Contribute_BAO_Contribution', 'contribution_status_id', $statusId) === 'Completed') {
1791               $update = FALSE;
1792             }
1793           }
1794           if ($membership && $update) {
1795             $newStatus = array_search('Cancelled', $membershipStatuses);
1796
1797             // Create activity
1798             $allStatus = CRM_Member_BAO_Membership::buildOptions('status_id', 'get');
1799             $activityParam = array(
1800               'subject' => "Status changed from {$allStatus[$membership->status_id]} to {$allStatus[$newStatus]}",
1801               'source_contact_id' => CRM_Core_Session::singleton()->get('userID'),
1802               'target_contact_id' => $membership->contact_id,
1803               'source_record_id' => $membership->id,
1804               'activity_type_id' => 'Change Membership Status',
1805               'status_id' => 'Completed',
1806               'priority_id' => 'Normal',
1807               'activity_date_time' => 'now',
1808             );
1809
1810             $membership->status_id = $newStatus;
1811             $membership->is_override = TRUE;
1812             $membership->status_override_end_date = 'null';
1813             $membership->save();
1814             civicrm_api3('activity', 'create', $activityParam);
1815
1816             $updateResult['updatedComponents']['CiviMember'] = $membership->status_id;
1817             if ($processContributionObject) {
1818               $processContribution = TRUE;
1819             }
1820           }
1821         }
1822       }
1823
1824       if ($participant) {
1825         $updatedStatusId = array_search('Cancelled', $participantStatuses);
1826         CRM_Event_BAO_Participant::updateParticipantStatus($participant->id, $oldStatus, $updatedStatusId, TRUE);
1827
1828         $updateResult['updatedComponents']['CiviEvent'] = $updatedStatusId;
1829         if ($processContributionObject) {
1830           $processContribution = TRUE;
1831         }
1832       }
1833
1834       if ($pledgePayment) {
1835         CRM_Pledge_BAO_PledgePayment::updatePledgePaymentStatus($pledgeID, $pledgePaymentIDs, $contributionStatusId);
1836
1837         $updateResult['updatedComponents']['CiviPledge'] = $contributionStatusId;
1838         if ($processContributionObject) {
1839           $processContribution = TRUE;
1840         }
1841       }
1842     }
1843     elseif ($contributionStatusId == array_search('Failed', $contributionStatuses)) {
1844       if (is_array($memberships)) {
1845         foreach ($memberships as $membership) {
1846           $update = TRUE;
1847           //Update Membership status if there is no other completed contribution associated with the membership.
1848           $relatedContributions = CRM_Member_BAO_Membership::getMembershipContributionId($membership->id, TRUE);
1849           foreach ($relatedContributions as $contriId) {
1850             if ($contriId == $contributionId) {
1851               continue;
1852             }
1853             $statusId = CRM_Core_DAO::getFieldValue('CRM_Contribute_BAO_Contribution', $contriId, 'contribution_status_id');
1854             if (CRM_Core_PseudoConstant::getName('CRM_Contribute_BAO_Contribution', 'contribution_status_id', $statusId) === 'Completed') {
1855               $update = FALSE;
1856             }
1857           }
1858           if ($membership && $update) {
1859             $membership->status_id = array_search('Expired', $membershipStatuses);
1860             $membership->is_override = TRUE;
1861             $membership->status_override_end_date = 'null';
1862             $membership->save();
1863
1864             $updateResult['updatedComponents']['CiviMember'] = $membership->status_id;
1865             if ($processContributionObject) {
1866               $processContribution = TRUE;
1867             }
1868           }
1869         }
1870       }
1871       if ($participant) {
1872         $updatedStatusId = array_search('Cancelled', $participantStatuses);
1873         CRM_Event_BAO_Participant::updateParticipantStatus($participant->id, $oldStatus, $updatedStatusId, TRUE);
1874
1875         $updateResult['updatedComponents']['CiviEvent'] = $updatedStatusId;
1876         if ($processContributionObject) {
1877           $processContribution = TRUE;
1878         }
1879       }
1880
1881       if ($pledgePayment) {
1882         CRM_Pledge_BAO_PledgePayment::updatePledgePaymentStatus($pledgeID, $pledgePaymentIDs, $contributionStatusId);
1883
1884         $updateResult['updatedComponents']['CiviPledge'] = $contributionStatusId;
1885         if ($processContributionObject) {
1886           $processContribution = TRUE;
1887         }
1888       }
1889     }
1890     elseif ($contributionStatusId == array_search('Completed', $contributionStatuses)) {
1891
1892       // only pending contribution related object processed.
1893       if ($previousContriStatusId &&
1894         !in_array($contributionStatuses[$previousContriStatusId], array('Pending', 'Partially paid'))
1895       ) {
1896         // this is case when we already processed contribution object.
1897         return $updateResult;
1898       }
1899       elseif (!$previousContriStatusId &&
1900         !in_array($contributionStatuses[$contribution->contribution_status_id], array('Pending', 'Partially paid'))
1901       ) {
1902         // this is case when we are going to process contribution object later.
1903         return $updateResult;
1904       }
1905
1906       if (is_array($memberships)) {
1907         foreach ($memberships as $membership) {
1908           if ($membership) {
1909             $format = '%Y%m%d';
1910
1911             //CRM-4523
1912             $currentMembership = CRM_Member_BAO_Membership::getContactMembership($membership->contact_id,
1913               $membership->membership_type_id,
1914               $membership->is_test, $membership->id
1915             );
1916
1917             // CRM-8141 update the membership type with the value recorded in log when membership created/renewed
1918             // this picks up membership type changes during renewals
1919             $sql = "
1920               SELECT    membership_type_id
1921               FROM      civicrm_membership_log
1922               WHERE     membership_id=$membership->id
1923               ORDER BY  id DESC
1924               LIMIT     1;";
1925             $dao = new CRM_Core_DAO();
1926             $dao->query($sql);
1927             if ($dao->fetch()) {
1928               if (!empty($dao->membership_type_id)) {
1929                 $membership->membership_type_id = $dao->membership_type_id;
1930                 $membership->save();
1931               }
1932             }
1933             // else fall back to using current membership type
1934             // Figure out number of terms
1935             $numterms = 1;
1936             $lineitems = CRM_Price_BAO_LineItem::getLineItemsByContributionID($contributionId);
1937             foreach ($lineitems as $lineitem) {
1938               if ($membership->membership_type_id == CRM_Utils_Array::value('membership_type_id', $lineitem)) {
1939                 $numterms = CRM_Utils_Array::value('membership_num_terms', $lineitem);
1940
1941                 // in case membership_num_terms comes through as null or zero
1942                 $numterms = $numterms >= 1 ? $numterms : 1;
1943                 break;
1944               }
1945             }
1946
1947             // CRM-15735-to update the membership status as per the contribution receive date
1948             $joinDate = NULL;
1949             $oldStatus = $membership->status_id;
1950             if (!empty($params['receive_date'])) {
1951               $joinDate = $params['receive_date'];
1952               $status = CRM_Member_BAO_MembershipStatus::getMembershipStatusByDate($membership->start_date,
1953                 $membership->end_date,
1954                 $membership->join_date,
1955                 $params['receive_date'],
1956                 FALSE,
1957                 $membership->membership_type_id,
1958                 (array) $membership
1959               );
1960               $membership->status_id = CRM_Utils_Array::value('id', $status, $membership->status_id);
1961               $membership->save();
1962             }
1963
1964             if ($currentMembership) {
1965               CRM_Member_BAO_Membership::fixMembershipStatusBeforeRenew($currentMembership, NULL);
1966               $dates = CRM_Member_BAO_MembershipType::getRenewalDatesForMembershipType($membership->id, NULL, NULL, $numterms);
1967               $dates['join_date'] = CRM_Utils_Date::customFormat($currentMembership['join_date'], $format);
1968             }
1969             else {
1970               $dates = CRM_Member_BAO_MembershipType::getDatesForMembershipType($membership->membership_type_id, $joinDate, NULL, NULL, $numterms);
1971             }
1972
1973             //get the status for membership.
1974             $calcStatus = CRM_Member_BAO_MembershipStatus::getMembershipStatusByDate($dates['start_date'],
1975               $dates['end_date'],
1976               $dates['join_date'],
1977               'today',
1978               TRUE,
1979               $membership->membership_type_id,
1980               (array) $membership
1981             );
1982
1983             $formattedParams = array(
1984               'status_id' => CRM_Utils_Array::value('id', $calcStatus,
1985                 array_search('Current', $membershipStatuses)
1986               ),
1987               'join_date' => CRM_Utils_Date::customFormat($dates['join_date'], $format),
1988               'start_date' => CRM_Utils_Date::customFormat($dates['start_date'], $format),
1989               'end_date' => CRM_Utils_Date::customFormat($dates['end_date'], $format),
1990             );
1991
1992             CRM_Utils_Hook::pre('edit', 'Membership', $membership->id, $formattedParams);
1993
1994             $membership->copyValues($formattedParams);
1995             $membership->save();
1996
1997             //updating the membership log
1998             $membershipLog = array();
1999             $membershipLog = $formattedParams;
2000             $logStartDate = CRM_Utils_Date::customFormat(CRM_Utils_Array::value('log_start_date', $dates), $format);
2001             $logStartDate = ($logStartDate) ? CRM_Utils_Date::isoToMysql($logStartDate) : $formattedParams['start_date'];
2002
2003             $membershipLog['start_date'] = $logStartDate;
2004             $membershipLog['membership_id'] = $membership->id;
2005             $membershipLog['modified_id'] = $membership->contact_id;
2006             $membershipLog['modified_date'] = date('Ymd');
2007             $membershipLog['membership_type_id'] = $membership->membership_type_id;
2008
2009             CRM_Member_BAO_MembershipLog::add($membershipLog);
2010
2011             //update related Memberships.
2012             CRM_Member_BAO_Membership::updateRelatedMemberships($membership->id, $formattedParams);
2013
2014             foreach (array('Membership Signup', 'Membership Renewal') as $activityType) {
2015               $scheduledActivityID = CRM_Utils_Array::value('id',
2016                 civicrm_api3('Activity', 'Get',
2017                   array(
2018                     'source_record_id' => $membership->id,
2019                     'activity_type_id' => $activityType,
2020                     'status_id' => 'Scheduled',
2021                     'options' => array(
2022                       'limit' => 1,
2023                       'sort' => 'id DESC',
2024                     ),
2025                   )
2026                 )
2027               );
2028               // 1. Update Schedule Membership Signup/Renewal activity to completed on successful payment of pending membership
2029               // 2. OR Create renewal activity scheduled if its membership renewal will be paid later
2030               if ($scheduledActivityID) {
2031                 CRM_Activity_BAO_Activity::addActivity($membership, $activityType, $membership->contact_id, array('id' => $scheduledActivityID));
2032                 break;
2033               }
2034             }
2035
2036             // track membership status change if any
2037             if (!empty($oldStatus) && $membership->status_id != $oldStatus) {
2038               $allStatus = CRM_Member_BAO_Membership::buildOptions('status_id', 'get');
2039               CRM_Activity_BAO_Activity::addActivity($membership,
2040                 'Change Membership Status',
2041                 NULL,
2042                 array(
2043                   'subject' => "Status changed from {$allStatus[$oldStatus]} to {$allStatus[$membership->status_id]}",
2044                   'source_contact_id' => $membershipLog['modified_id'],
2045                   'priority_id' => 'Normal',
2046                 )
2047               );
2048             }
2049
2050             $updateResult['updatedComponents']['CiviMember'] = $membership->status_id;
2051             if ($processContributionObject) {
2052               $processContribution = TRUE;
2053             }
2054
2055             CRM_Utils_Hook::post('edit', 'Membership', $membership->id, $membership);
2056           }
2057         }
2058       }
2059
2060       if ($participant) {
2061         $updatedStatusId = array_search('Registered', $participantStatuses);
2062         CRM_Event_BAO_Participant::updateParticipantStatus($participant->id, $oldStatus, $updatedStatusId, TRUE);
2063
2064         $updateResult['updatedComponents']['CiviEvent'] = $updatedStatusId;
2065         if ($processContributionObject) {
2066           $processContribution = TRUE;
2067         }
2068       }
2069
2070       if ($pledgePayment) {
2071         CRM_Pledge_BAO_PledgePayment::updatePledgePaymentStatus($pledgeID, $pledgePaymentIDs, $contributionStatusId);
2072
2073         $updateResult['updatedComponents']['CiviPledge'] = $contributionStatusId;
2074         if ($processContributionObject) {
2075           $processContribution = TRUE;
2076         }
2077       }
2078     }
2079
2080     // process contribution object.
2081     if ($processContribution) {
2082       $contributionParams = array();
2083       $fields = array(
2084         'contact_id',
2085         'total_amount',
2086         'receive_date',
2087         'is_test',
2088         'campaign_id',
2089         'payment_instrument_id',
2090         'trxn_id',
2091         'invoice_id',
2092         'financial_type_id',
2093         'contribution_status_id',
2094         'non_deductible_amount',
2095         'receipt_date',
2096         'check_number',
2097       );
2098       foreach ($fields as $field) {
2099         if (empty($params[$field])) {
2100           continue;
2101         }
2102         $contributionParams[$field] = $params[$field];
2103       }
2104
2105       $ids = array('contribution' => $contributionId);
2106       $contribution = CRM_Contribute_BAO_Contribution::create($contributionParams, $ids);
2107     }
2108
2109     return $updateResult;
2110   }
2111
2112   /**
2113    * Returns all contribution related object ids.
2114    *
2115    * @param $contributionId
2116    *
2117    * @return array
2118    */
2119   public static function getComponentDetails($contributionId) {
2120     $componentDetails = $pledgePayment = array();
2121     if (!$contributionId) {
2122       return $componentDetails;
2123     }
2124
2125     $query = "
2126       SELECT    c.id                 as contribution_id,
2127                 c.contact_id         as contact_id,
2128                 c.contribution_recur_id,
2129                 mp.membership_id     as membership_id,
2130                 m.membership_type_id as membership_type_id,
2131                 pp.participant_id    as participant_id,
2132                 p.event_id           as event_id,
2133                 pgp.id               as pledge_payment_id
2134       FROM      civicrm_contribution c
2135       LEFT JOIN civicrm_membership_payment  mp   ON mp.contribution_id = c.id
2136       LEFT JOIN civicrm_participant_payment pp   ON pp.contribution_id = c.id
2137       LEFT JOIN civicrm_participant         p    ON pp.participant_id  = p.id
2138       LEFT JOIN civicrm_membership          m    ON m.id  = mp.membership_id
2139       LEFT JOIN civicrm_pledge_payment      pgp  ON pgp.contribution_id  = c.id
2140       WHERE     c.id = $contributionId";
2141
2142     $dao = CRM_Core_DAO::executeQuery($query);
2143     $componentDetails = array();
2144
2145     while ($dao->fetch()) {
2146       $componentDetails['component'] = $dao->participant_id ? 'event' : 'contribute';
2147       $componentDetails['contact_id'] = $dao->contact_id;
2148       if ($dao->event_id) {
2149         $componentDetails['event'] = $dao->event_id;
2150       }
2151       if ($dao->participant_id) {
2152         $componentDetails['participant'] = $dao->participant_id;
2153       }
2154       if ($dao->membership_id) {
2155         if (!isset($componentDetails['membership'])) {
2156           $componentDetails['membership'] = $componentDetails['membership_type'] = array();
2157         }
2158         $componentDetails['membership'][] = $dao->membership_id;
2159         $componentDetails['membership_type'][] = $dao->membership_type_id;
2160       }
2161       if ($dao->pledge_payment_id) {
2162         $pledgePayment[] = $dao->pledge_payment_id;
2163       }
2164       if ($dao->contribution_recur_id) {
2165         $componentDetails['contributionRecur'] = $dao->contribution_recur_id;
2166       }
2167     }
2168
2169     if ($pledgePayment) {
2170       $componentDetails['pledge_payment'] = $pledgePayment;
2171     }
2172
2173     return $componentDetails;
2174   }
2175
2176   /**
2177    * @param int $contactId
2178    * @param bool $includeSoftCredit
2179    *
2180    * @return null|string
2181    */
2182   public static function contributionCount($contactId, $includeSoftCredit = TRUE) {
2183     if (!$contactId) {
2184       return 0;
2185     }
2186     $financialTypes = CRM_Financial_BAO_FinancialType::getAllAvailableFinancialTypes();
2187     $additionalWhere = " AND contribution.financial_type_id IN (0)";
2188     $liWhere = " AND i.financial_type_id IN (0)";
2189     if (!empty($financialTypes)) {
2190       $additionalWhere = " AND contribution.financial_type_id IN (" . implode(',', array_keys($financialTypes)) . ")";
2191       $liWhere = " AND i.financial_type_id NOT IN (" . implode(',', array_keys($financialTypes)) . ")";
2192     }
2193     $contactContributionsSQL = "
2194       SELECT contribution.id AS id
2195       FROM civicrm_contribution contribution
2196       LEFT JOIN civicrm_line_item i ON i.contribution_id = contribution.id AND i.entity_table = 'civicrm_contribution' $liWhere
2197       WHERE contribution.is_test = 0 AND contribution.contact_id = {$contactId}
2198       $additionalWhere
2199       AND i.id IS NULL";
2200
2201     $contactSoftCreditContributionsSQL = "
2202       SELECT contribution.id
2203       FROM civicrm_contribution contribution INNER JOIN civicrm_contribution_soft softContribution
2204       ON ( contribution.id = softContribution.contribution_id )
2205       WHERE contribution.is_test = 0 AND softContribution.contact_id = {$contactId} ";
2206     $query = "SELECT count( x.id ) count FROM ( ";
2207     $query .= $contactContributionsSQL;
2208
2209     if ($includeSoftCredit) {
2210       $query .= " UNION ";
2211       $query .= $contactSoftCreditContributionsSQL;
2212     }
2213
2214     $query .= ") x";
2215
2216     return CRM_Core_DAO::singleValueQuery($query);
2217   }
2218
2219   /**
2220    * Repeat a transaction as part of a recurring series.
2221    *
2222    * Only call this via the api as it is being refactored. The intention is that the repeatTransaction function
2223    * (possibly living on the ContributionRecur BAO) would be called first to create a pending contribution with a
2224    * subsequent call to the contribution.completetransaction api.
2225    *
2226    * The completeTransaction functionality has historically been overloaded to both complete and repeat payments.
2227    *
2228    * @param CRM_Contribute_BAO_Contribution $contribution
2229    * @param array $input
2230    * @param array $contributionParams
2231    * @param int $paymentProcessorID
2232    *
2233    * @return bool
2234    * @throws CiviCRM_API3_Exception
2235    */
2236   protected static function repeatTransaction(&$contribution, &$input, $contributionParams, $paymentProcessorID) {
2237     if (!empty($contribution->id)) {
2238       return FALSE;
2239     }
2240     if (empty($contribution->id)) {
2241       // Unclear why this would only be set for repeats.
2242       if (!empty($input['amount'])) {
2243         $contribution->total_amount = $contributionParams['total_amount'] = $input['amount'];
2244       }
2245
2246       if (!empty($contributionParams['contribution_recur_id'])) {
2247         $recurringContribution = civicrm_api3('ContributionRecur', 'getsingle', array(
2248           'id' => $contributionParams['contribution_recur_id'],
2249         ));
2250         if (!empty($recurringContribution['campaign_id'])) {
2251           // CRM-17718 the campaign id on the contribution recur record should get precedence.
2252           $contributionParams['campaign_id'] = $recurringContribution['campaign_id'];
2253         }
2254         if (!empty($recurringContribution['financial_type_id'])) {
2255           // CRM-17718 the campaign id on the contribution recur record should get precedence.
2256           $contributionParams['financial_type_id'] = $recurringContribution['financial_type_id'];
2257         }
2258       }
2259       $templateContribution = CRM_Contribute_BAO_ContributionRecur::getTemplateContribution(
2260         $contributionParams['contribution_recur_id'],
2261         array_intersect_key($contributionParams, array('total_amount' => TRUE, 'financial_type_id' => TRUE))
2262       );
2263       $input['line_item'] = $contributionParams['line_item'] = $templateContribution['line_item'];
2264
2265       $contributionParams['status_id'] = 'Pending';
2266       if (isset($contributionParams['financial_type_id'])) {
2267         // Give precedence to passed in type.
2268         $contribution->financial_type_id = $contributionParams['financial_type_id'];
2269       }
2270       else {
2271         $contributionParams['financial_type_id'] = $templateContribution['financial_type_id'];
2272       }
2273       $contributionParams['contact_id'] = $templateContribution['contact_id'];
2274       $contributionParams['source'] = empty($templateContribution['source']) ? ts('Recurring contribution') : $templateContribution['source'];
2275
2276       //CRM-18805 -- Contribution page not recorded on recurring transactions, Recurring contribution payments
2277       //do not create CC or BCC emails or profile notifications.
2278       //The if is just to be safe. Not sure if we can ever arrive with this unset
2279       // but per CRM-19478 it seems it can be 'null'
2280       if (isset($contribution->contribution_page_id) && is_numeric($contribution->contribution_page_id)) {
2281         $contributionParams['contribution_page_id'] = $contribution->contribution_page_id;
2282       }
2283
2284       $createContribution = civicrm_api3('Contribution', 'create', $contributionParams);
2285       $contribution->id = $createContribution['id'];
2286       CRM_Contribute_BAO_ContributionRecur::copyCustomValues($contributionParams['contribution_recur_id'], $contribution->id);
2287       return TRUE;
2288     }
2289   }
2290
2291   /**
2292    * Get individual id for onbehalf contribution.
2293    *
2294    * @param int $contributionId
2295    *   Contribution id.
2296    * @param int $contributorId
2297    *   Contributor id.
2298    *
2299    * @return array
2300    *   containing organization id and individual id
2301    */
2302   public static function getOnbehalfIds($contributionId, $contributorId = NULL) {
2303
2304     $ids = array();
2305
2306     if (!$contributionId) {
2307       return $ids;
2308     }
2309
2310     // fetch contributor id if null
2311     if (!$contributorId) {
2312       $contributorId = CRM_Core_DAO::getFieldValue('CRM_Contribute_DAO_Contribution',
2313         $contributionId, 'contact_id'
2314       );
2315     }
2316
2317     $activityTypeIds = CRM_Core_PseudoConstant::activityType(TRUE, FALSE, FALSE, 'name');
2318     $activityTypeId = array_search('Contribution', $activityTypeIds);
2319
2320     if ($activityTypeId && $contributorId) {
2321       $activityQuery = "
2322 SELECT     civicrm_activity_contact.contact_id
2323   FROM     civicrm_activity_contact
2324 INNER JOIN civicrm_activity ON civicrm_activity_contact.activity_id = civicrm_activity.id
2325  WHERE     civicrm_activity.activity_type_id   = %1
2326    AND     civicrm_activity.source_record_id   = %2
2327    AND     civicrm_activity_contact.record_type_id = %3
2328 ";
2329
2330       $activityContacts = CRM_Activity_BAO_ActivityContact::buildOptions('record_type_id', 'validate');
2331       $sourceID = CRM_Utils_Array::key('Activity Source', $activityContacts);
2332
2333       $params = array(
2334         1 => array($activityTypeId, 'Integer'),
2335         2 => array($contributionId, 'Integer'),
2336         3 => array($sourceID, 'Integer'),
2337       );
2338
2339       $sourceContactId = CRM_Core_DAO::singleValueQuery($activityQuery, $params);
2340
2341       // for on behalf contribution source is individual and contributor is organization
2342       if ($sourceContactId && $sourceContactId != $contributorId) {
2343         $relationshipTypeIds = CRM_Core_PseudoConstant::relationshipType('name');
2344         // get rel type id for employee of relation
2345         foreach ($relationshipTypeIds as $id => $typeVals) {
2346           if ($typeVals['name_a_b'] == 'Employee of') {
2347             $relationshipTypeId = $id;
2348             break;
2349           }
2350         }
2351
2352         $rel = new CRM_Contact_DAO_Relationship();
2353         $rel->relationship_type_id = $relationshipTypeId;
2354         $rel->contact_id_a = $sourceContactId;
2355         $rel->contact_id_b = $contributorId;
2356         if ($rel->find(TRUE)) {
2357           $ids['individual_id'] = $rel->contact_id_a;
2358           $ids['organization_id'] = $rel->contact_id_b;
2359         }
2360       }
2361     }
2362
2363     return $ids;
2364   }
2365
2366   /**
2367    * @return array
2368    */
2369   public static function getContributionDates() {
2370     $config = CRM_Core_Config::singleton();
2371     $currentMonth = date('m');
2372     $currentDay = date('d');
2373     if ((int ) $config->fiscalYearStart['M'] > $currentMonth ||
2374       ((int ) $config->fiscalYearStart['M'] == $currentMonth &&
2375         (int ) $config->fiscalYearStart['d'] > $currentDay
2376       )
2377     ) {
2378       $year = date('Y') - 1;
2379     }
2380     else {
2381       $year = date('Y');
2382     }
2383     $year = array('Y' => $year);
2384     $yearDate = $config->fiscalYearStart;
2385     $yearDate = array_merge($year, $yearDate);
2386     $yearDate = CRM_Utils_Date::format($yearDate);
2387
2388     $monthDate = date('Ym') . '01';
2389
2390     $now = date('Ymd');
2391
2392     return array(
2393       'now' => $now,
2394       'yearDate' => $yearDate,
2395       'monthDate' => $monthDate,
2396     );
2397   }
2398
2399   /**
2400    * Load objects relations to contribution object.
2401    * Objects are stored in the $_relatedObjects property
2402    * In the first instance we are just moving functionality from BASEIpn -
2403    * @see http://issues.civicrm.org/jira/browse/CRM-9996
2404    *
2405    * Note that the unit test for the BaseIPN class tests this function
2406    *
2407    * @param array $input
2408    *   Input as delivered from Payment Processor.
2409    * @param array $ids
2410    *   Ids as Loaded by Payment Processor.
2411    * @param bool $loadAll
2412    *   Load all related objects - even where id not passed in? (allows API to call this).
2413    *
2414    * @return bool
2415    * @throws Exception
2416    */
2417   public function loadRelatedObjects(&$input, &$ids, $loadAll = FALSE) {
2418     // @todo deprecate this function - the steps should be
2419     // 1) add additional functions like 'getRelatedMemberships'
2420     // 2) switch all calls that refer to ->_relatedObjects to
2421     // using the helper functions
2422     // 3) make ->_relatedObjects noisy in some way (deprecation won't work for properties - hmm
2423     // 4) make ->_relatedObjects protected
2424     // 5) hone up the individual functions to not use rely on this having been called
2425     // 6) deprecate like mad
2426     if ($loadAll) {
2427       $ids = array_merge($this->getComponentDetails($this->id), $ids);
2428       if (empty($ids['contact']) && isset($this->contact_id)) {
2429         $ids['contact'] = $this->contact_id;
2430       }
2431     }
2432     if (empty($this->_component)) {
2433       if (!empty($ids['event'])) {
2434         $this->_component = 'event';
2435       }
2436       else {
2437         $this->_component = strtolower(CRM_Utils_Array::value('component', $input, 'contribute'));
2438       }
2439     }
2440
2441     // If the object is not fully populated then make sure it is - this is a more about legacy paths & cautious
2442     // refactoring than anything else, and has unit test coverage.
2443     if (empty($this->financial_type_id)) {
2444       $this->find(TRUE);
2445     }
2446
2447     $paymentProcessorID = CRM_Utils_Array::value('payment_processor_id', $input, CRM_Utils_Array::value(
2448       'paymentProcessor',
2449       $ids
2450     ));
2451
2452     if (!isset($input['payment_processor_id']) && !$paymentProcessorID && $this->contribution_page_id) {
2453       $paymentProcessorID = CRM_Core_DAO::getFieldValue('CRM_Contribute_DAO_ContributionPage',
2454         $this->contribution_page_id,
2455         'payment_processor'
2456       );
2457       if ($paymentProcessorID) {
2458         $intentionalEnotice = $CRM16923AnUnreliableMethodHasBeenUserToDeterminePaymentProcessorFromContributionPage;
2459       }
2460     }
2461
2462     $ids['contributionType'] = $this->financial_type_id;
2463     $ids['financialType'] = $this->financial_type_id;
2464     if ($this->contribution_page_id) {
2465       $ids['contributionPage'] = $this->contribution_page_id;
2466     }
2467
2468     $this->loadRelatedEntitiesByID($ids);
2469
2470     if (!empty($ids['contributionRecur']) && !$paymentProcessorID) {
2471       $paymentProcessorID = $this->_relatedObjects['contributionRecur']->payment_processor_id;
2472     }
2473
2474     if (!empty($ids['pledge_payment'])) {
2475       foreach ($ids['pledge_payment'] as $key => $paymentID) {
2476         if (empty($paymentID)) {
2477           continue;
2478         }
2479         $payment = new CRM_Pledge_BAO_PledgePayment();
2480         $payment->id = $paymentID;
2481         if (!$payment->find(TRUE)) {
2482           throw new Exception("Could not find pledge payment record: " . $paymentID);
2483         }
2484         $this->_relatedObjects['pledge_payment'][] = $payment;
2485       }
2486     }
2487
2488     // These are probably no longer accessed from anywhere
2489     // @todo remove this line, after ensuring not used.
2490     $ids = $this->loadRelatedMembershipObjects($ids);
2491
2492     if ($this->_component != 'contribute') {
2493       // we are in event mode
2494       // make sure event exists and is valid
2495       $event = new CRM_Event_BAO_Event();
2496       $event->id = $ids['event'];
2497       if ($ids['event'] &&
2498         !$event->find(TRUE)
2499       ) {
2500         throw new Exception("Could not find event: " . $ids['event']);
2501       }
2502
2503       $this->_relatedObjects['event'] = &$event;
2504
2505       $participant = new CRM_Event_BAO_Participant();
2506       $participant->id = $ids['participant'];
2507       if ($ids['participant'] &&
2508         !$participant->find(TRUE)
2509       ) {
2510         throw new Exception("Could not find participant: " . $ids['participant']);
2511       }
2512       $participant->register_date = CRM_Utils_Date::isoToMysql($participant->register_date);
2513
2514       $this->_relatedObjects['participant'] = &$participant;
2515
2516       // get the payment processor id from event - this is inaccurate see CRM-16923
2517       // in future we should look at throwing an exception here rather than an dubious guess.
2518       if (!$paymentProcessorID) {
2519         $paymentProcessorID = $this->_relatedObjects['event']->payment_processor;
2520         if ($paymentProcessorID) {
2521           $intentionalEnotice = $CRM16923AnUnreliableMethodHasBeenUserToDeterminePaymentProcessorFromEvent;
2522         }
2523       }
2524     }
2525
2526     if ($paymentProcessorID) {
2527       $paymentProcessor = CRM_Financial_BAO_PaymentProcessor::getPayment($paymentProcessorID,
2528         $this->is_test ? 'test' : 'live'
2529       );
2530       $ids['paymentProcessor'] = $paymentProcessorID;
2531       $this->_relatedObjects['paymentProcessor'] = $paymentProcessor;
2532     }
2533
2534     // Add contribution id to $ids. CRM-20401
2535     $ids['contribution'] = $this->id;
2536     return TRUE;
2537   }
2538
2539   /**
2540    * Create array of message information - ie. return html version, txt version, to field
2541    *
2542    * @param array $input
2543    *   Incoming information.
2544    *   - is_recur - should this be treated as recurring (not sure why you wouldn't
2545    *    just check presence of recur object but maintaining legacy approach
2546    *    to be careful)
2547    * @param array $ids
2548    *   IDs of related objects.
2549    * @param array $values
2550    *   Any values that may have already been compiled by calling process.
2551    *   This is augmented by values 'gathered' by gatherMessageValues
2552    * @param bool $returnMessageText
2553    *   Distinguishes between whether to send message or return.
2554    *   message text. We are working towards this function ALWAYS returning message text & calling
2555    *   function doing emails / pdfs with it
2556    *
2557    * @return array
2558    *   messages
2559    * @throws Exception
2560    */
2561   public function composeMessageArray(&$input, &$ids, &$values, $returnMessageText = TRUE) {
2562     $this->loadRelatedObjects($input, $ids);
2563
2564     if (empty($this->_component)) {
2565       $this->_component = CRM_Utils_Array::value('component', $input);
2566     }
2567
2568     //not really sure what params might be passed in but lets merge em into values
2569     $values = array_merge($this->_gatherMessageValues($input, $values, $ids), $values);
2570     $values['is_email_receipt'] = $this->isEmailReceipt($input, $values);
2571     if (!empty($input['receipt_date'])) {
2572       $values['receipt_date'] = $input['receipt_date'];
2573     }
2574
2575     $template = $this->_assignMessageVariablesToTemplate($values, $input, $returnMessageText);
2576     //what does recur 'mean here - to do with payment processor return functionality but
2577     // what is the importance
2578     if (!empty($this->contribution_recur_id) && !empty($this->_relatedObjects['paymentProcessor'])) {
2579       $paymentObject = Civi\Payment\System::singleton()->getByProcessor($this->_relatedObjects['paymentProcessor']);
2580
2581       $entityID = $entity = NULL;
2582       if (isset($ids['contribution'])) {
2583         $entity = 'contribution';
2584         $entityID = $ids['contribution'];
2585       }
2586       if (!empty($ids['membership'])) {
2587         //not sure whether is is possible for this not to be an array - load related contacts loads an array but this code was expecting a string
2588         // the addition of the casting is in case it could get here & be a string. Added in 4.6 - maybe remove later? This AuthorizeNetIPN & PaypalIPN tests hit this
2589         // line having loaded an array
2590         $ids['membership'] = (array) $ids['membership'];
2591         $entity = 'membership';
2592         $entityID = $ids['membership'][0];
2593       }
2594
2595       $template->assign('cancelSubscriptionUrl', $paymentObject->subscriptionURL($entityID, $entity, 'cancel'));
2596       $template->assign('updateSubscriptionBillingUrl', $paymentObject->subscriptionURL($entityID, $entity, 'billing'));
2597       $template->assign('updateSubscriptionUrl', $paymentObject->subscriptionURL($entityID, $entity, 'update'));
2598
2599       if ($this->_relatedObjects['paymentProcessor']['billing_mode'] & CRM_Core_Payment::BILLING_MODE_FORM) {
2600         //direct mode showing billing block, so use directIPN for temporary
2601         $template->assign('contributeMode', 'directIPN');
2602       }
2603     }
2604     // todo remove strtolower - check consistency
2605     if (strtolower($this->_component) == 'event') {
2606       $eventParams = array('id' => $this->_relatedObjects['participant']->event_id);
2607       $values['event'] = array();
2608
2609       CRM_Event_BAO_Event::retrieve($eventParams, $values['event']);
2610
2611       //get location details
2612       $locationParams = array('entity_id' => $this->_relatedObjects['participant']->event_id, 'entity_table' => 'civicrm_event');
2613       $values['location'] = CRM_Core_BAO_Location::getValues($locationParams);
2614
2615       $ufJoinParams = array(
2616         'entity_table' => 'civicrm_event',
2617         'entity_id' => $ids['event'],
2618         'module' => 'CiviEvent',
2619       );
2620
2621       list($custom_pre_id,
2622         $custom_post_ids
2623         ) = CRM_Core_BAO_UFJoin::getUFGroupIds($ufJoinParams);
2624
2625       $values['custom_pre_id'] = $custom_pre_id;
2626       $values['custom_post_id'] = $custom_post_ids;
2627       //for tasks 'Change Participant Status' and 'Update multiple Contributions' case
2628       //and cases involving status updation through ipn
2629       // whatever that means!
2630       // total_amount appears to be the preferred input param & it is unclear why we support amount here
2631       // perhaps we should throw an e-notice if amount is set & force total_amount?
2632       if (!empty($input['amount'])) {
2633         $values['totalAmount'] = $input['amount'];
2634       }
2635       // @todo set this in is_email_receipt, based on $this->_relatedObjects.
2636       if ($values['event']['is_email_confirm']) {
2637         $values['is_email_receipt'] = 1;
2638       }
2639
2640       if (!empty($ids['contribution'])) {
2641         $values['contributionId'] = $ids['contribution'];
2642       }
2643
2644       return CRM_Event_BAO_Event::sendMail($ids['contact'], $values,
2645         $this->_relatedObjects['participant']->id, $this->is_test, $returnMessageText
2646       );
2647     }
2648     else {
2649       $values['contribution_id'] = $this->id;
2650       if (!empty($ids['related_contact'])) {
2651         $values['related_contact'] = $ids['related_contact'];
2652         if (isset($ids['onbehalf_dupe_alert'])) {
2653           $values['onbehalf_dupe_alert'] = $ids['onbehalf_dupe_alert'];
2654         }
2655         $entityBlock = array(
2656           'contact_id' => $ids['contact'],
2657           'location_type_id' => CRM_Core_DAO::getFieldValue('CRM_Core_DAO_LocationType',
2658             'Home', 'id', 'name'
2659           ),
2660         );
2661         $address = CRM_Core_BAO_Address::getValues($entityBlock);
2662         $template->assign('onBehalfAddress', $address[$entityBlock['location_type_id']]['display']);
2663       }
2664       $isTest = FALSE;
2665       if ($this->is_test) {
2666         $isTest = TRUE;
2667       }
2668       if (!empty($this->_relatedObjects['membership'])) {
2669         foreach ($this->_relatedObjects['membership'] as $membership) {
2670           if ($membership->id) {
2671             $values['membership_id'] = $membership->id;
2672             $values['isMembership'] = TRUE;
2673             $values['membership_assign'] = TRUE;
2674
2675             // need to set the membership values here
2676             $template->assign('membership_name',
2677               CRM_Member_PseudoConstant::membershipType($membership->membership_type_id)
2678             );
2679             $template->assign('mem_start_date', $membership->start_date);
2680             $template->assign('mem_join_date', $membership->join_date);
2681             $template->assign('mem_end_date', $membership->end_date);
2682             $membership_status = CRM_Member_PseudoConstant::membershipStatus($membership->status_id, NULL, 'label');
2683             $template->assign('mem_status', $membership_status);
2684             if ($membership_status == 'Pending' && $membership->is_pay_later == 1) {
2685               $values['is_pay_later'] = 1;
2686             }
2687             // Pass amount to floatval as string '0.00' is considered a
2688             // valid amount and includes Fee section in the mail.
2689             if (isset($values['amount'])) {
2690               $values['amount'] = floatval($values['amount']);
2691             }
2692
2693             if (!empty($this->contribution_recur_id) && $paymentObject) {
2694               $url = $paymentObject->subscriptionURL($membership->id, 'membership', 'cancel');
2695               $template->assign('cancelSubscriptionUrl', $url);
2696               $url = $paymentObject->subscriptionURL($membership->id, 'membership', 'billing');
2697               $template->assign('updateSubscriptionBillingUrl', $url);
2698               $url = $paymentObject->subscriptionURL($entityID, $entity, 'update');
2699               $template->assign('updateSubscriptionUrl', $url);
2700             }
2701
2702             $result = CRM_Contribute_BAO_ContributionPage::sendMail($ids['contact'], $values, $isTest, $returnMessageText);
2703
2704             return $result;
2705             // otherwise if its about sending emails, continue sending without return, as we
2706             // don't want to exit the loop.
2707           }
2708         }
2709       }
2710       else {
2711         return CRM_Contribute_BAO_ContributionPage::sendMail($ids['contact'], $values, $isTest, $returnMessageText);
2712       }
2713     }
2714   }
2715
2716   /**
2717    * Gather values for contribution mail - this function has been created
2718    * as part of CRM-9996 refactoring as a step towards simplifying the composeMessage function
2719    * Values related to the contribution in question are gathered
2720    *
2721    * @param array $input
2722    *   Input into function (probably from payment processor).
2723    * @param array $values
2724    * @param array $ids
2725    *   The set of ids related to the input.
2726    *
2727    * @return array
2728    */
2729   public function _gatherMessageValues($input, &$values, $ids = array()) {
2730     // set display address of contributor
2731     if ($this->address_id) {
2732       $addressParams = array('id' => $this->address_id);
2733       $addressDetails = CRM_Core_BAO_Address::getValues($addressParams, FALSE, 'id');
2734       $addressDetails = array_values($addressDetails);
2735     }
2736     // Else we assign the billing address of the contribution contact.
2737     else {
2738       $addressParams = array('contact_id' => $this->contact_id, 'is_billing' => 1);
2739       $addressDetails = (array) CRM_Core_BAO_Address::getValues($addressParams);
2740       $addressDetails = array_values($addressDetails);
2741     }
2742
2743     if (!empty($addressDetails[0]['display'])) {
2744       $values['address'] = $addressDetails[0]['display'];
2745     }
2746
2747     if ($this->_component == 'contribute') {
2748       //get soft contributions
2749       $softContributions = CRM_Contribute_BAO_ContributionSoft::getSoftContribution($this->id, TRUE);
2750       if (!empty($softContributions)) {
2751         $values['softContributions'] = $softContributions['soft_credit'];
2752       }
2753       if (isset($this->contribution_page_id)) {
2754         // This is a call we want to use less, in favour of loading related objects.
2755         $values = $this->addContributionPageValuesToValuesHeavyHandedly($values);
2756         if ($this->contribution_page_id) {
2757           // This is precautionary as there are some legacy flows, but it should really be
2758           // loaded by now.
2759           if (!isset($this->_relatedObjects['contributionPage'])) {
2760             $this->loadRelatedEntitiesByID(array('contributionPage' => $this->contribution_page_id));
2761           }
2762           // CRM-8254 - override default currency if applicable
2763           $config = CRM_Core_Config::singleton();
2764           $config->defaultCurrency = CRM_Utils_Array::value(
2765             'currency',
2766             $values,
2767             $config->defaultCurrency
2768           );
2769         }
2770       }
2771       // no contribution page -probably back office
2772       else {
2773         // Handle re-print receipt for offline contributions (call from PDF.php - no contribution_page_id)
2774         $values['title'] = 'Contribution';
2775       }
2776       // set lineItem for contribution
2777       if ($this->id) {
2778         $lineItems = CRM_Price_BAO_LineItem::getLineItemsByContributionID($this->id);
2779         if (!empty($lineItems)) {
2780           $firstLineItem = reset($lineItems);
2781           $priceSet = array();
2782           if (CRM_Utils_Array::value('price_set_id', $firstLineItem)) {
2783             $priceSet = civicrm_api3('PriceSet', 'getsingle', array('id' => $firstLineItem['price_set_id'], 'return' => 'is_quick_config, id'));
2784             $values['priceSetID'] = $priceSet['id'];
2785           }
2786           foreach ($lineItems as &$eachItem) {
2787             if (isset($this->_relatedObjects['membership'])
2788              && is_array($this->_relatedObjects['membership'])
2789              && array_key_exists($eachItem['membership_type_id'], $this->_relatedObjects['membership'])) {
2790               $eachItem['join_date'] = CRM_Utils_Date::customFormat($this->_relatedObjects['membership'][$eachItem['membership_type_id']]->join_date);
2791               $eachItem['start_date'] = CRM_Utils_Date::customFormat($this->_relatedObjects['membership'][$eachItem['membership_type_id']]->start_date);
2792               $eachItem['end_date'] = CRM_Utils_Date::customFormat($this->_relatedObjects['membership'][$eachItem['membership_type_id']]->end_date);
2793             }
2794             // This is actually used in conjunction with is_quick_config in the template & we should deprecate it.
2795             // However, that does create upgrade pain so would be better to be phased in.
2796             $values['useForMember'] = empty($priceSet['is_quick_config']);
2797           }
2798           $values['lineItem'][0] = $lineItems;
2799         }
2800       }
2801
2802       $relatedContact = CRM_Contribute_BAO_Contribution::getOnbehalfIds(
2803         $this->id,
2804         $this->contact_id
2805       );
2806       // if this is onbehalf of contribution then set related contact
2807       if (!empty($relatedContact['individual_id'])) {
2808         $values['related_contact'] = $ids['related_contact'] = $relatedContact['individual_id'];
2809       }
2810     }
2811     else {
2812       // event
2813       $eventParams = array(
2814         'id' => $this->_relatedObjects['event']->id,
2815       );
2816       $values['event'] = array();
2817
2818       CRM_Event_BAO_Event::retrieve($eventParams, $values['event']);
2819       // add custom fields for event
2820       $eventGroupTree = CRM_Core_BAO_CustomGroup::getTree('Event', NULL, $this->_relatedObjects['event']->id);
2821
2822       $eventCustomGroup = array();
2823       foreach ($eventGroupTree as $key => $group) {
2824         if ($key === 'info') {
2825           continue;
2826         }
2827
2828         foreach ($group['fields'] as $k => $customField) {
2829           $groupLabel = $group['title'];
2830           if (!empty($customField['customValue'])) {
2831             foreach ($customField['customValue'] as $customFieldValues) {
2832               $eventCustomGroup[$groupLabel][$customField['label']] = CRM_Utils_Array::value('data', $customFieldValues);
2833             }
2834           }
2835         }
2836       }
2837       $values['event']['customGroup'] = $eventCustomGroup;
2838
2839       //get participant details
2840       $participantParams = array(
2841         'id' => $this->_relatedObjects['participant']->id,
2842       );
2843
2844       $values['participant'] = array();
2845
2846       CRM_Event_BAO_Participant::getValues($participantParams, $values['participant'], $participantIds);
2847       // add custom fields for event
2848       $participantGroupTree = CRM_Core_BAO_CustomGroup::getTree('Participant', NULL, $this->_relatedObjects['participant']->id);
2849       $participantCustomGroup = array();
2850       foreach ($participantGroupTree as $key => $group) {
2851         if ($key === 'info') {
2852           continue;
2853         }
2854
2855         foreach ($group['fields'] as $k => $customField) {
2856           $groupLabel = $group['title'];
2857           if (!empty($customField['customValue'])) {
2858             foreach ($customField['customValue'] as $customFieldValues) {
2859               $participantCustomGroup[$groupLabel][$customField['label']] = CRM_Utils_Array::value('data', $customFieldValues);
2860             }
2861           }
2862         }
2863       }
2864       $values['participant']['customGroup'] = $participantCustomGroup;
2865
2866       //get location details
2867       $locationParams = array(
2868         'entity_id' => $this->_relatedObjects['event']->id,
2869         'entity_table' => 'civicrm_event',
2870       );
2871       $values['location'] = CRM_Core_BAO_Location::getValues($locationParams);
2872
2873       $ufJoinParams = array(
2874         'entity_table' => 'civicrm_event',
2875         'entity_id' => $ids['event'],
2876         'module' => 'CiviEvent',
2877       );
2878
2879       list($custom_pre_id,
2880         $custom_post_ids
2881         ) = CRM_Core_BAO_UFJoin::getUFGroupIds($ufJoinParams);
2882
2883       $values['custom_pre_id'] = $custom_pre_id;
2884       $values['custom_post_id'] = $custom_post_ids;
2885
2886       // set lineItem for event contribution
2887       if ($this->id) {
2888         $participantIds = CRM_Event_BAO_Participant::getParticipantIds($this->id);
2889         if (!empty($participantIds)) {
2890           foreach ($participantIds as $pIDs) {
2891             $lineItem = CRM_Price_BAO_LineItem::getLineItems($pIDs);
2892             if (!CRM_Utils_System::isNull($lineItem)) {
2893               $values['lineItem'][] = $lineItem;
2894             }
2895           }
2896         }
2897       }
2898     }
2899
2900     $groupTree = CRM_Core_BAO_CustomGroup::getTree('Contribution', NULL, $this->id);
2901
2902     $customGroup = array();
2903     foreach ($groupTree as $key => $group) {
2904       if ($key === 'info') {
2905         continue;
2906       }
2907
2908       foreach ($group['fields'] as $k => $customField) {
2909         $groupLabel = $group['title'];
2910         if (!empty($customField['customValue'])) {
2911           foreach ($customField['customValue'] as $customFieldValues) {
2912             $customGroup[$groupLabel][$customField['label']] = CRM_Utils_Array::value('data', $customFieldValues);
2913           }
2914         }
2915       }
2916     }
2917     $values['customGroup'] = $customGroup;
2918
2919     $values['is_pay_later'] = $this->is_pay_later;
2920
2921     return $values;
2922   }
2923
2924   /**
2925    * Assign message variables to template but try to break the habit.
2926    *
2927    * In order to get away from leaky variables it is better to ensure variables are set in values and assign them
2928    * from the send function. Otherwise smarty variables can leak if this is called more than once - e.g. processing
2929    * multiple recurring payments for processors like IATS that use tokens.
2930    *
2931    * Apply variables for message to smarty template - this function is part of analysing what is in the huge
2932    * function & breaking it down into manageable chunks. Eventually it will be refactored into something else
2933    * Note we send directly from this function in some cases because it is only partly refactored.
2934    *
2935    * Don't call this function directly as the signature will change.
2936    *
2937    * @param $values
2938    * @param $input
2939    * @param bool $returnMessageText
2940    *
2941    * @return mixed
2942    */
2943   public function _assignMessageVariablesToTemplate(&$values, $input, $returnMessageText = TRUE) {
2944     // @todo - this should have a better separation of concerns - ie.
2945     // gatherMessageValues should build an array of values to be assigned to the template
2946     // and this function should assign them (assigning null if not set).
2947     // the way the pcpParams & honor Params section works is a baby-step towards this.
2948     $template = CRM_Core_Smarty::singleton();
2949     $template->assign('first_name', $this->_relatedObjects['contact']->first_name);
2950     $template->assign('last_name', $this->_relatedObjects['contact']->last_name);
2951     $template->assign('displayName', $this->_relatedObjects['contact']->display_name);
2952
2953     // For some unit tests contribution cannot contain paymentProcessor information
2954     $billingMode = empty($this->_relatedObjects['paymentProcessor']) ? CRM_Core_Payment::BILLING_MODE_NOTIFY : $this->_relatedObjects['paymentProcessor']['billing_mode'];
2955     $template->assign('contributeMode', CRM_Utils_Array::value($billingMode, CRM_Core_SelectValues::contributeMode()));
2956
2957     //assign honor information to receipt message
2958     $softRecord = CRM_Contribute_BAO_ContributionSoft::getSoftContribution($this->id);
2959
2960     $honorParams = ['soft_credit_type' => NULL, 'honor_block_is_active' => NULL];
2961     if (isset($softRecord['soft_credit'])) {
2962       //if id of contribution page is present
2963       if (!empty($values['id'])) {
2964         $values['honor'] = array(
2965           'honor_profile_values' => array(),
2966           'honor_profile_id' => CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFJoin', $values['id'], 'uf_group_id', 'entity_id'),
2967           'honor_id' => $softRecord['soft_credit'][1]['contact_id'],
2968         );
2969
2970         $honorParams['soft_credit_type'] = $softRecord['soft_credit'][1]['soft_credit_type_label'];
2971         $honorParams['honor_block_is_active'] = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFJoin', $values['id'], 'is_active', 'entity_id');
2972       }
2973       else {
2974         //offline contribution
2975         $softCreditTypes = $softCredits = array();
2976         foreach ($softRecord['soft_credit'] as $key => $softCredit) {
2977           $softCreditTypes[$key] = $softCredit['soft_credit_type_label'];
2978           $softCredits[$key] = array(
2979             'Name' => $softCredit['contact_name'],
2980             'Amount' => CRM_Utils_Money::format($softCredit['amount'], $softCredit['currency']),
2981           );
2982         }
2983         $template->assign('softCreditTypes', $softCreditTypes);
2984         $template->assign('softCredits', $softCredits);
2985       }
2986     }
2987
2988     $dao = new CRM_Contribute_DAO_ContributionProduct();
2989     $dao->contribution_id = $this->id;
2990     if ($dao->find(TRUE)) {
2991       $premiumId = $dao->product_id;
2992       $template->assign('option', $dao->product_option);
2993
2994       $productDAO = new CRM_Contribute_DAO_Product();
2995       $productDAO->id = $premiumId;
2996       $productDAO->find(TRUE);
2997       $template->assign('selectPremium', TRUE);
2998       $template->assign('product_name', $productDAO->name);
2999       $template->assign('price', $productDAO->price);
3000       $template->assign('sku', $productDAO->sku);
3001     }
3002     $template->assign('title', CRM_Utils_Array::value('title', $values));
3003     $values['amount'] = CRM_Utils_Array::value('total_amount', $input, (CRM_Utils_Array::value('amount', $input)), NULL);
3004     if (!$values['amount'] && isset($this->total_amount)) {
3005       $values['amount'] = $this->total_amount;
3006     }
3007
3008     $pcpParams = ['pcpBlock' => NULL, 'pcp_display_in_roll' => NULL, 'pcp_roll_nickname' => NULL, 'pcp_personal_note' => NULL, 'title' => NULL];
3009
3010     if (strtolower($this->_component) == 'contribute') {
3011       //PCP Info
3012       $softDAO = new CRM_Contribute_DAO_ContributionSoft();
3013       $softDAO->contribution_id = $this->id;
3014       if ($softDAO->find(TRUE)) {
3015         $pcpParams['pcpBlock'] = TRUE;
3016         $pcpParams['pcp_display_in_roll'] = $softDAO->pcp_display_in_roll;
3017         $pcpParams['pcp_roll_nickname'] = $softDAO->pcp_roll_nickname;
3018         $pcpParams['pcp_personal_note'] = $softDAO->pcp_personal_note;
3019
3020         //assign the pcp page title for email subject
3021         $pcpDAO = new CRM_PCP_DAO_PCP();
3022         $pcpDAO->id = $softDAO->pcp_id;
3023         if ($pcpDAO->find(TRUE)) {
3024           $pcpParams['title'] = $pcpDAO->title;
3025         }
3026       }
3027     }
3028     foreach (array_merge($honorParams, $pcpParams) as $templateKey => $templateValue) {
3029       $template->assign($templateKey, $templateValue);
3030     }
3031
3032     if ($this->financial_type_id) {
3033       $values['financial_type_id'] = $this->financial_type_id;
3034     }
3035
3036     $template->assign('trxn_id', $this->trxn_id);
3037     $template->assign('receive_date',
3038       CRM_Utils_Date::processDate($this->receive_date)
3039     );
3040     $values['receipt_date'] = (empty($this->receipt_date) ? NULL : $this->receipt_date);
3041     $template->assign('action', $this->is_test ? 1024 : 1);
3042     $template->assign('receipt_text',
3043       CRM_Utils_Array::value('receipt_text',
3044         $values
3045       )
3046     );
3047     $template->assign('is_monetary', 1);
3048     $template->assign('is_recur', !empty($this->contribution_recur_id));
3049     $template->assign('currency', $this->currency);
3050     $template->assign('address', CRM_Utils_Address::format($input));
3051     if (!empty($values['customGroup'])) {
3052       $template->assign('customGroup', $values['customGroup']);
3053     }
3054     if (!empty($values['softContributions'])) {
3055       $template->assign('softContributions', $values['softContributions']);
3056     }
3057     if ($this->_component == 'event') {
3058       $template->assign('title', $values['event']['title']);
3059       $participantRoles = CRM_Event_PseudoConstant::participantRole();
3060       $viewRoles = array();
3061       foreach (explode(CRM_Core_DAO::VALUE_SEPARATOR, $this->_relatedObjects['participant']->role_id) as $k => $v) {
3062         $viewRoles[] = $participantRoles[$v];
3063       }
3064       $values['event']['participant_role'] = implode(', ', $viewRoles);
3065       $template->assign('event', $values['event']);
3066       $template->assign('participant', $values['participant']);
3067       $template->assign('location', $values['location']);
3068       $template->assign('customPre', $values['custom_pre_id']);
3069       $template->assign('customPost', $values['custom_post_id']);
3070
3071       $isTest = FALSE;
3072       if ($this->_relatedObjects['participant']->is_test) {
3073         $isTest = TRUE;
3074       }
3075
3076       $values['params'] = array();
3077       //to get email of primary participant.
3078       $primaryEmail = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_Email', $this->_relatedObjects['participant']->contact_id, 'email', 'contact_id');
3079       $primaryAmount[] = array(
3080         'label' => $this->_relatedObjects['participant']->fee_level . ' - ' . $primaryEmail,
3081         'amount' => $this->_relatedObjects['participant']->fee_amount,
3082       );
3083       //build an array of cId/pId of participants
3084       $additionalIDs = CRM_Event_BAO_Event::buildCustomProfile($this->_relatedObjects['participant']->id, NULL, $this->_relatedObjects['contact']->id, $isTest, TRUE);
3085       unset($additionalIDs[$this->_relatedObjects['participant']->id]);
3086       //send receipt to additional participant if exists
3087       if (count($additionalIDs)) {
3088         $template->assign('isPrimary', 0);
3089         $template->assign('customProfile', NULL);
3090         //set additionalParticipant true
3091         $values['params']['additionalParticipant'] = TRUE;
3092         foreach ($additionalIDs as $pId => $cId) {
3093           $amount = array();
3094           //to change the status pending to completed
3095           $additional = new CRM_Event_DAO_Participant();
3096           $additional->id = $pId;
3097           $additional->contact_id = $cId;
3098           $additional->find(TRUE);
3099           $additional->register_date = $this->_relatedObjects['participant']->register_date;
3100           $additional->status_id = 1;
3101           $additionalParticipantInfo = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_Email', $additional->contact_id, 'email', 'contact_id');
3102           //if additional participant dont have email
3103           //use display name.
3104           if (!$additionalParticipantInfo) {
3105             $additionalParticipantInfo = CRM_Contact_BAO_Contact::displayName($additional->contact_id);
3106           }
3107           $amount[0] = array('label' => $additional->fee_level, 'amount' => $additional->fee_amount);
3108           $primaryAmount[] = array(
3109             'label' => $additional->fee_level . ' - ' . $additionalParticipantInfo,
3110             'amount' => $additional->fee_amount,
3111           );
3112           $additional->save();
3113           $template->assign('amount', $amount);
3114           CRM_Event_BAO_Event::sendMail($cId, $values, $pId, $isTest, $returnMessageText);
3115         }
3116       }
3117
3118       //build an array of custom profile and assigning it to template
3119       $customProfile = CRM_Event_BAO_Event::buildCustomProfile($this->_relatedObjects['participant']->id, $values, NULL, $isTest);
3120
3121       if (count($customProfile)) {
3122         $template->assign('customProfile', $customProfile);
3123       }
3124
3125       // for primary contact
3126       $values['params']['additionalParticipant'] = FALSE;
3127       $template->assign('isPrimary', 1);
3128       $template->assign('amount', $primaryAmount);
3129       $template->assign('register_date', CRM_Utils_Date::isoToMysql($this->_relatedObjects['participant']->register_date));
3130       if ($this->payment_instrument_id) {
3131         $paymentInstrument = CRM_Contribute_PseudoConstant::paymentInstrument();
3132         $template->assign('paidBy', $paymentInstrument[$this->payment_instrument_id]);
3133       }
3134       // carry paylater, since we did not created billing,
3135       // so need to pull email from primary location, CRM-4395
3136       $values['params']['is_pay_later'] = $this->_relatedObjects['participant']->is_pay_later;
3137     }
3138     return $template;
3139   }
3140
3141   /**
3142    * Check whether payment processor supports
3143    * cancellation of contribution subscription
3144    *
3145    * @param int $contributionId
3146    *   Contribution id.
3147    *
3148    * @param bool $isNotCancelled
3149    *
3150    * @return bool
3151    */
3152   public static function isCancelSubscriptionSupported($contributionId, $isNotCancelled = TRUE) {
3153     $cacheKeyString = "$contributionId";
3154     $cacheKeyString .= $isNotCancelled ? '_1' : '_0';
3155
3156     static $supportsCancel = array();
3157
3158     if (!array_key_exists($cacheKeyString, $supportsCancel)) {
3159       $supportsCancel[$cacheKeyString] = FALSE;
3160       $isCancelled = FALSE;
3161
3162       if ($isNotCancelled) {
3163         $isCancelled = self::isSubscriptionCancelled($contributionId);
3164       }
3165
3166       $paymentObject = CRM_Financial_BAO_PaymentProcessor::getProcessorForEntity($contributionId, 'contribute', 'obj');
3167       if (!empty($paymentObject)) {
3168         $supportsCancel[$cacheKeyString] = $paymentObject->supports('cancelRecurring') && !$isCancelled;
3169       }
3170     }
3171     return $supportsCancel[$cacheKeyString];
3172   }
3173
3174   /**
3175    * Check whether subscription is already cancelled.
3176    *
3177    * @param int $contributionId
3178    *   Contribution id.
3179    *
3180    * @return string
3181    *   contribution status
3182    */
3183   public static function isSubscriptionCancelled($contributionId) {
3184     $sql = "
3185        SELECT cr.contribution_status_id
3186          FROM civicrm_contribution_recur cr
3187     LEFT JOIN civicrm_contribution con ON ( cr.id = con.contribution_recur_id )
3188         WHERE con.id = %1 LIMIT 1";
3189     $params = array(1 => array($contributionId, 'Integer'));
3190     $statusId = CRM_Core_DAO::singleValueQuery($sql, $params);
3191     $status = CRM_Contribute_PseudoConstant::contributionStatus($statusId);
3192     if ($status == 'Cancelled') {
3193       return TRUE;
3194     }
3195     return FALSE;
3196   }
3197
3198   /**
3199    * Create all financial accounts entry.
3200    *
3201    * @param array $params
3202    *   Contribution object, line item array and params for trxn.
3203    *
3204    *
3205    * @param array $financialTrxnValues
3206    *
3207    * @return null|\CRM_Core_BAO_FinancialTrxn
3208    */
3209   public static function recordFinancialAccounts(&$params, $financialTrxnValues = NULL) {
3210     $skipRecords = $update = $return = $isRelatedId = FALSE;
3211
3212     $additionalParticipantId = array();
3213     $contributionStatuses = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
3214     $contributionStatus = empty($params['contribution_status_id']) ? NULL : $contributionStatuses[$params['contribution_status_id']];
3215
3216     if (CRM_Utils_Array::value('contribution_mode', $params) == 'participant') {
3217       $entityId = $params['participant_id'];
3218       $entityTable = 'civicrm_participant';
3219       $additionalParticipantId = CRM_Event_BAO_Participant::getAdditionalParticipantIds($entityId);
3220     }
3221     elseif (!empty($params['membership_id'])) {
3222       //so far $params['membership_id'] should only be set coming in from membershipBAO::create so the situation where multiple memberships
3223       // are created off one contribution should be handled elsewhere
3224       $entityId = $params['membership_id'];
3225       $entityTable = 'civicrm_membership';
3226     }
3227     else {
3228       $entityId = $params['contribution']->id;
3229       $entityTable = 'civicrm_contribution';
3230     }
3231
3232     if (CRM_Utils_Array::value('contribution_mode', $params) == 'membership') {
3233       $isRelatedId = TRUE;
3234     }
3235
3236     $entityID[] = $entityId;
3237     if (!empty($additionalParticipantId)) {
3238       $entityID += $additionalParticipantId;
3239     }
3240     // prevContribution appears to mean - original contribution object- ie copy of contribution from before the update started that is being updated
3241     if (empty($params['prevContribution'])) {
3242       $entityID = NULL;
3243     }
3244     else {
3245       $update = TRUE;
3246     }
3247
3248     $statusId = $params['contribution']->contribution_status_id;
3249     // CRM-13964 partial payment
3250     if ($contributionStatus == 'Partially paid'
3251       && !empty($params['partial_payment_total']) && !empty($params['partial_amount_to_pay'])
3252     ) {
3253       $partialAmtPay = CRM_Utils_Rule::cleanMoney($params['partial_amount_to_pay']);
3254       $partialAmtTotal = CRM_Utils_Rule::cleanMoney($params['partial_payment_total']);
3255
3256       $fromFinancialAccountId = CRM_Financial_BAO_FinancialAccount::getFinancialAccountForFinancialTypeByRelationship($params['financial_type_id'], 'Accounts Receivable Account is');
3257       $statusId = CRM_Core_PseudoConstant::getKey('CRM_Contribute_BAO_Contribution', 'contribution_status_id', 'Completed');
3258       $params['total_amount'] = $partialAmtPay;
3259
3260       $balanceTrxnInfo = CRM_Core_BAO_FinancialTrxn::getBalanceTrxnAmt($params['contribution']->id, $params['financial_type_id']);
3261       if (empty($balanceTrxnInfo['trxn_id'])) {
3262         // create new balance transaction record
3263         $toFinancialAccount = CRM_Financial_BAO_FinancialAccount::getFinancialAccountForFinancialTypeByRelationship($params['financial_type_id'], 'Accounts Receivable Account is');
3264
3265         $balanceTrxnParams['total_amount'] = $partialAmtTotal;
3266         $balanceTrxnParams['to_financial_account_id'] = $toFinancialAccount;
3267         $balanceTrxnParams['contribution_id'] = $params['contribution']->id;
3268         $balanceTrxnParams['trxn_date'] = !empty($params['contribution']->receive_date) ? $params['contribution']->receive_date : date('YmdHis');
3269         $balanceTrxnParams['fee_amount'] = CRM_Utils_Array::value('fee_amount', $params);
3270         $balanceTrxnParams['net_amount'] = CRM_Utils_Array::value('net_amount', $params);
3271         $balanceTrxnParams['currency'] = $params['contribution']->currency;
3272         $balanceTrxnParams['trxn_id'] = $params['contribution']->trxn_id;
3273         $balanceTrxnParams['status_id'] = $statusId;
3274         $balanceTrxnParams['payment_instrument_id'] = $params['contribution']->payment_instrument_id;
3275         $balanceTrxnParams['check_number'] = CRM_Utils_Array::value('check_number', $params);
3276         $balanceTrxnParams['pan_truncation'] = CRM_Utils_Array::value('pan_truncation', $params);
3277         $balanceTrxnParams['card_type_id'] = CRM_Utils_Array::value('card_type_id', $params);
3278         if (!empty($balanceTrxnParams['from_financial_account_id']) &&
3279           ($statusId == array_search('Completed', $contributionStatuses) || $statusId == array_search('Partially paid', $contributionStatuses))
3280         ) {
3281           $balanceTrxnParams['is_payment'] = 1;
3282         }
3283         if (!empty($params['payment_processor'])) {
3284           $balanceTrxnParams['payment_processor_id'] = $params['payment_processor'];
3285         }
3286         $financialTxn = CRM_Core_BAO_FinancialTrxn::create($balanceTrxnParams);
3287       }
3288     }
3289
3290     // build line item array if its not set in $params
3291     if (empty($params['line_item']) || $additionalParticipantId) {
3292       CRM_Price_BAO_LineItem::getLineItemArray($params, $entityID, str_replace('civicrm_', '', $entityTable), $isRelatedId);
3293     }
3294
3295     if ($contributionStatus != 'Failed' &&
3296       !($contributionStatus == 'Pending' && !$params['contribution']->is_pay_later)
3297     ) {
3298       $skipRecords = TRUE;
3299       $pendingStatus = array(
3300         'Pending',
3301         'In Progress',
3302       );
3303       if (in_array($contributionStatus, $pendingStatus)) {
3304         $params['to_financial_account_id'] = CRM_Financial_BAO_FinancialAccount::getFinancialAccountForFinancialTypeByRelationship(
3305           $params['financial_type_id'],
3306           'Accounts Receivable Account is'
3307         );
3308       }
3309       elseif (!empty($params['payment_processor'])) {
3310         $params['to_financial_account_id'] = CRM_Contribute_PseudoConstant::getRelationalFinancialAccount($params['payment_processor'], NULL, 'civicrm_payment_processor');
3311         $params['payment_instrument_id'] = civicrm_api3('PaymentProcessor', 'getvalue', array(
3312           'id' => $params['payment_processor'],
3313           'return' => 'payment_instrument_id',
3314         ));
3315       }
3316       elseif (!empty($params['payment_instrument_id'])) {
3317         $params['to_financial_account_id'] = CRM_Financial_BAO_FinancialTypeAccount::getInstrumentFinancialAccount($params['payment_instrument_id']);
3318       }
3319       else {
3320         $relationTypeId = key(CRM_Core_PseudoConstant::accountOptionValues('financial_account_type', NULL, " AND v.name LIKE 'Asset' "));
3321         $queryParams = array(1 => array($relationTypeId, 'Integer'));
3322         $params['to_financial_account_id'] = CRM_Core_DAO::singleValueQuery("SELECT id FROM civicrm_financial_account WHERE is_default = 1 AND financial_account_type_id = %1", $queryParams);
3323       }
3324
3325       $totalAmount = CRM_Utils_Array::value('total_amount', $params);
3326       if (!isset($totalAmount) && !empty($params['prevContribution'])) {
3327         $totalAmount = $params['total_amount'] = $params['prevContribution']->total_amount;
3328       }
3329       //build financial transaction params
3330       $trxnParams = array(
3331         'contribution_id' => $params['contribution']->id,
3332         'to_financial_account_id' => $params['to_financial_account_id'],
3333         'trxn_date' => !empty($params['contribution']->receive_date) ? $params['contribution']->receive_date : date('YmdHis'),
3334         'total_amount' => $totalAmount,
3335         'fee_amount' => CRM_Utils_Array::value('fee_amount', $params),
3336         'net_amount' => CRM_Utils_Array::value('net_amount', $params, $totalAmount),
3337         'currency' => $params['contribution']->currency,
3338         'trxn_id' => $params['contribution']->trxn_id,
3339         'status_id' => $statusId,
3340         'payment_instrument_id' => CRM_Utils_Array::value('payment_instrument_id', $params, $params['contribution']->payment_instrument_id),
3341         'check_number' => CRM_Utils_Array::value('check_number', $params),
3342         'pan_truncation' => CRM_Utils_Array::value('pan_truncation', $params),
3343         'card_type_id' => CRM_Utils_Array::value('card_type_id', $params),
3344       );
3345       if ($contributionStatus == 'Refunded' || $contributionStatus == 'Chargeback' || $contributionStatus == 'Cancelled') {
3346         $trxnParams['trxn_date'] = !empty($params['contribution']->cancel_date) ? $params['contribution']->cancel_date : date('YmdHis');
3347         if (isset($params['refund_trxn_id'])) {
3348           // CRM-17751 allow a separate trxn_id for the refund to be passed in via api & form.
3349           $trxnParams['trxn_id'] = $params['refund_trxn_id'];
3350         }
3351       }
3352       //CRM-16259, set is_payment flag for non pending status
3353       if (!in_array($contributionStatus, $pendingStatus)) {
3354         $trxnParams['is_payment'] = 1;
3355       }
3356       if (!empty($params['payment_processor'])) {
3357         $trxnParams['payment_processor_id'] = $params['payment_processor'];
3358       }
3359
3360       if (isset($fromFinancialAccountId)) {
3361         $trxnParams['from_financial_account_id'] = $fromFinancialAccountId;
3362       }
3363
3364       // consider external values passed for recording transaction entry
3365       if (!empty($financialTrxnValues)) {
3366         $trxnParams = array_merge($trxnParams, $financialTrxnValues);
3367       }
3368       if (empty($trxnParams['payment_processor_id'])) {
3369         unset($trxnParams['payment_processor_id']);
3370       }
3371
3372       $params['trxnParams'] = $trxnParams;
3373
3374       if (!empty($params['prevContribution'])) {
3375         $updated = FALSE;
3376         $params['trxnParams']['total_amount'] = $trxnParams['total_amount'] = $params['total_amount'] = $params['prevContribution']->total_amount;
3377         $params['trxnParams']['fee_amount'] = $params['prevContribution']->fee_amount;
3378         $params['trxnParams']['net_amount'] = $params['prevContribution']->net_amount;
3379         if (!isset($params['trxnParams']['trxn_id'])) {
3380           // Actually I have no idea why we are overwriting any values from the previous contribution.
3381           // (filling makes sense to me). However, only protecting this value as I really really know we
3382           // don't want this one overwritten.
3383           // CRM-17751.
3384           $params['trxnParams']['trxn_id'] = $params['prevContribution']->trxn_id;
3385         }
3386         $params['trxnParams']['status_id'] = $params['prevContribution']->contribution_status_id;
3387
3388         if (!(($params['prevContribution']->contribution_status_id == array_search('Pending', $contributionStatuses)
3389             || $params['prevContribution']->contribution_status_id == array_search('In Progress', $contributionStatuses))
3390           && $params['contribution']->contribution_status_id == array_search('Completed', $contributionStatuses))
3391         ) {
3392           $params['trxnParams']['payment_instrument_id'] = $params['prevContribution']->payment_instrument_id;
3393           $params['trxnParams']['check_number'] = $params['prevContribution']->check_number;
3394         }
3395
3396         //if financial type is changed
3397         if (!empty($params['financial_type_id']) &&
3398           $params['contribution']->financial_type_id != $params['prevContribution']->financial_type_id
3399         ) {
3400           $accountRelationship = 'Income Account is';
3401           if (!empty($params['revenue_recognition_date']) || $params['prevContribution']->revenue_recognition_date) {
3402             $accountRelationship = 'Deferred Revenue Account is';
3403           }
3404           $oldFinancialAccount = CRM_Financial_BAO_FinancialAccount::getFinancialAccountForFinancialTypeByRelationship($params['prevContribution']->financial_type_id, $accountRelationship);
3405           $newFinancialAccount = CRM_Financial_BAO_FinancialAccount::getFinancialAccountForFinancialTypeByRelationship($params['financial_type_id'], $accountRelationship);
3406           if ($oldFinancialAccount != $newFinancialAccount) {
3407             $params['total_amount'] = 0;
3408             if (in_array($params['contribution']->contribution_status_id, $pendingStatus)) {
3409               $params['trxnParams']['to_financial_account_id'] = CRM_Financial_BAO_FinancialAccount::getFinancialAccountForFinancialTypeByRelationship(
3410                 $params['prevContribution']->financial_type_id, $accountRelationship);
3411             }
3412             else {
3413               $lastFinancialTrxnId = CRM_Core_BAO_FinancialTrxn::getFinancialTrxnId($params['prevContribution']->id, 'DESC');
3414               if (!empty($lastFinancialTrxnId['financialTrxnId'])) {
3415                 $params['trxnParams']['to_financial_account_id'] = CRM_Core_DAO::getFieldValue('CRM_Financial_DAO_FinancialTrxn', $lastFinancialTrxnId['financialTrxnId'], 'to_financial_account_id');
3416               }
3417             }
3418             self::updateFinancialAccounts($params, 'changeFinancialType');
3419             /* $params['trxnParams']['to_financial_account_id'] = $trxnParams['to_financial_account_id']; */
3420             $params['financial_account_id'] = $newFinancialAccount;
3421             $params['total_amount'] = $params['trxnParams']['total_amount'] = $params['trxnParams']['net_amount'] = $trxnParams['total_amount'];
3422             self::updateFinancialAccounts($params);
3423             $params['trxnParams']['to_financial_account_id'] = $trxnParams['to_financial_account_id'];
3424             $updated = TRUE;
3425             $params['deferred_financial_account_id'] = $newFinancialAccount;
3426           }
3427         }
3428
3429         //Update contribution status
3430         $params['trxnParams']['status_id'] = $params['contribution']->contribution_status_id;
3431         if (!isset($params['refund_trxn_id'])) {
3432           // CRM-17751 This has previously been deliberately set. No explanation as to why one variant
3433           // gets preference over another so I am only 'protecting' a very specific tested flow
3434           // and letting natural justice take care of the rest.
3435           $params['trxnParams']['trxn_id'] = $params['contribution']->trxn_id;
3436         }
3437         if (!empty($params['contribution_status_id']) &&
3438           $params['prevContribution']->contribution_status_id != $params['contribution']->contribution_status_id
3439         ) {
3440           //Update Financial Records
3441           self::updateFinancialAccounts($params, 'changedStatus');
3442           $updated = TRUE;
3443         }
3444
3445         // change Payment Instrument for a Completed contribution
3446         // first handle special case when contribution is changed from Pending to Completed status when initial payment
3447         // instrument is null and now new payment instrument is added along with the payment
3448         if (!$params['contribution']->payment_instrument_id) {
3449           $params['contribution']->find(TRUE);
3450         }
3451         $params['trxnParams']['payment_instrument_id'] = $params['contribution']->payment_instrument_id;
3452         $params['trxnParams']['check_number'] = CRM_Utils_Array::value('check_number', $params);
3453
3454         if (self::isPaymentInstrumentChange($params, $pendingStatus)) {
3455           $updated = CRM_Core_BAO_FinancialTrxn::updateFinancialAccountsOnPaymentInstrumentChange($params);
3456         }
3457
3458         //if Change contribution amount
3459         $params['trxnParams']['fee_amount'] = CRM_Utils_Array::value('fee_amount', $params);
3460         $params['trxnParams']['net_amount'] = CRM_Utils_Array::value('net_amount', $params);
3461         $params['trxnParams']['total_amount'] = $trxnParams['total_amount'] = $params['total_amount'] = $totalAmount;
3462         $params['trxnParams']['trxn_id'] = $params['contribution']->trxn_id;
3463         if (isset($totalAmount) &&
3464           $totalAmount != $params['prevContribution']->total_amount
3465         ) {
3466           //Update Financial Records
3467           $params['trxnParams']['from_financial_account_id'] = NULL;
3468           self::updateFinancialAccounts($params, 'changedAmount');
3469           $updated = TRUE;
3470         }
3471
3472         if (!$updated) {
3473           // Looks like we might have a data correction update.
3474           // This would be a case where a transaction id has been entered but it is incorrect &
3475           // the person goes back in & fixes it, as opposed to a new transaction.
3476           // Currently the UI doesn't support multiple refunds against a single transaction & we are only supporting
3477           // the data fix scenario.
3478           // CRM-17751.
3479           if (isset($params['refund_trxn_id'])) {
3480             $refundIDs = CRM_Core_BAO_FinancialTrxn::getRefundTransactionIDs($params['id']);
3481             if (!empty($refundIDs['financialTrxnId']) && $refundIDs['trxn_id'] != $params['refund_trxn_id']) {
3482               civicrm_api3('FinancialTrxn', 'create', array('id' => $refundIDs['financialTrxnId'], 'trxn_id' => $params['refund_trxn_id']));
3483             }
3484           }
3485           $cardType = CRM_Utils_Array::value('card_type_id', $params);
3486           $panTruncation = CRM_Utils_Array::value('pan_truncation', $params);
3487           CRM_Core_BAO_FinancialTrxn::updateCreditCardDetails($params['contribution']->id, $panTruncation, $cardType);
3488         }
3489       }
3490
3491       if (!$update) {
3492         // records finanical trxn and entity financial trxn
3493         // also make it available as return value
3494         self::recordAlwaysAccountsReceivable($trxnParams, $params);
3495         $trxnParams['pan_truncation'] = CRM_Utils_Array::value('pan_truncation', $params);
3496         $trxnParams['card_type_id'] = CRM_Utils_Array::value('card_type_id', $params);
3497         $return = $financialTxn = CRM_Core_BAO_FinancialTrxn::create($trxnParams);
3498         $params['entity_id'] = $financialTxn->id;
3499         if (empty($params['partial_payment_total']) && empty($params['partial_amount_to_pay'])) {
3500           self::$_trxnIDs[] = $financialTxn->id;
3501         }
3502       }
3503     }
3504     // record line items and financial items
3505     if (empty($params['skipLineItem'])) {
3506       CRM_Price_BAO_LineItem::processPriceSet($entityId, CRM_Utils_Array::value('line_item', $params), $params['contribution'], $entityTable, $update);
3507     }
3508
3509     // create batch entry if batch_id is passed and
3510     // ensure no batch entry is been made on 'Pending' or 'Failed' contribution, CRM-16611
3511     if (!empty($params['batch_id']) && !empty($financialTxn)) {
3512       $entityParams = array(
3513         'batch_id' => $params['batch_id'],
3514         'entity_table' => 'civicrm_financial_trxn',
3515         'entity_id' => $financialTxn->id,
3516       );
3517       CRM_Batch_BAO_EntityBatch::create($entityParams);
3518     }
3519
3520     // when a fee is charged
3521     if (!empty($params['fee_amount']) && (empty($params['prevContribution']) || $params['contribution']->fee_amount != $params['prevContribution']->fee_amount) && $skipRecords) {
3522       CRM_Core_BAO_FinancialTrxn::recordFees($params);
3523     }
3524
3525     if (!empty($params['prevContribution']) && $entityTable == 'civicrm_participant'
3526       && $params['prevContribution']->contribution_status_id != $params['contribution']->contribution_status_id
3527     ) {
3528       $eventID = CRM_Core_DAO::getFieldValue('CRM_Event_DAO_Participant', $entityId, 'event_id');
3529       $feeLevel[] = str_replace('\ 1', '', $params['prevContribution']->amount_level);
3530       CRM_Event_BAO_Participant::createDiscountTrxn($eventID, $params, $feeLevel);
3531     }
3532     unset($params['line_item']);
3533     self::$_trxnIDs = NULL;
3534     return $return;
3535   }
3536
3537   /**
3538    * Update all financial accounts entry.
3539    *
3540    * @param array $params
3541    *   Contribution object, line item array and params for trxn.
3542    *
3543    * @todo stop passing $params by reference. It is unclear the purpose of doing this &
3544    * adds unpredictability.
3545    *
3546    * @param string $context
3547    *   Update scenarios.
3548    *
3549    */
3550   public static function updateFinancialAccounts(&$params, $context = NULL) {
3551     $trxnID = NULL;
3552     $inputParams = $params;
3553     $isARefund = FALSE;
3554     $currentContributionStatus = CRM_Core_PseudoConstant::getLabel('CRM_Contribute_BAO_Contribution', 'contribution_status_id', $params['contribution']->contribution_status_id);
3555     $previousContributionStatus = CRM_Contribute_PseudoConstant::contributionStatus($params['prevContribution']->contribution_status_id, 'name');
3556
3557     if (($previousContributionStatus == 'Pending'
3558         || $previousContributionStatus == 'In Progress')
3559       && $currentContributionStatus == 'Completed'
3560       && $context == 'changePaymentInstrument'
3561     ) {
3562       return;
3563     }
3564     if ((($previousContributionStatus == 'Partially paid'
3565       && $currentContributionStatus == 'Completed')
3566       || ($previousContributionStatus == 'Pending' && $params['prevContribution']->is_pay_later == TRUE
3567       && $currentContributionStatus == 'Partially paid'))
3568       && $context == 'changedStatus'
3569     ) {
3570       return;
3571     }
3572     if ($context == 'changedAmount' || $context == 'changeFinancialType') {
3573       // @todo we should stop passing $params by reference - splitting this out would be a step towards that.
3574       $params['trxnParams']['total_amount'] = $params['trxnParams']['net_amount'] = ($params['total_amount'] - $params['prevContribution']->total_amount);
3575     }
3576     if ($context == 'changedStatus') {
3577       if ($previousContributionStatus == 'Completed'
3578         && (self::isContributionStatusNegative($params['contribution']->contribution_status_id))
3579       ) {
3580         $isARefund = TRUE;
3581         // @todo we should stop passing $params by reference - splitting this out would be a step towards that.
3582         $params['trxnParams']['total_amount'] = -$params['total_amount'];
3583         if (empty($params['contribution']->creditnote_id) || $params['contribution']->creditnote_id == "null") {
3584           $creditNoteId = self::createCreditNoteId();
3585           CRM_Core_DAO::setFieldValue('CRM_Contribute_DAO_Contribution', $params['contribution']->id, 'creditnote_id', $creditNoteId);
3586         }
3587       }
3588       elseif (($previousContributionStatus == 'Pending'
3589           && $params['prevContribution']->is_pay_later) || $previousContributionStatus == 'In Progress'
3590       ) {
3591         $financialTypeID = CRM_Utils_Array::value('financial_type_id', $params) ? $params['financial_type_id'] : $params['prevContribution']->financial_type_id;
3592         $arAccountId = CRM_Contribute_PseudoConstant::getRelationalFinancialAccount($financialTypeID, 'Accounts Receivable Account is');
3593
3594         if ($currentContributionStatus == 'Cancelled') {
3595           // @todo we should stop passing $params by reference - splitting this out would be a step towards that.
3596           $params['trxnParams']['to_financial_account_id'] = $arAccountId;
3597           $params['trxnParams']['total_amount'] = -$params['total_amount'];
3598           if (is_null($params['contribution']->creditnote_id) || $params['contribution']->creditnote_id == "null") {
3599             $creditNoteId = self::createCreditNoteId();
3600             CRM_Core_DAO::setFieldValue('CRM_Contribute_DAO_Contribution', $params['contribution']->id, 'creditnote_id', $creditNoteId);
3601           }
3602         }
3603         else {
3604           // @todo we should stop passing $params by reference - splitting this out would be a step towards that.
3605           $params['trxnParams']['from_financial_account_id'] = $arAccountId;
3606         }
3607       }
3608     }
3609
3610     if ($context == 'changedStatus') {
3611       if (($previousContributionStatus == 'Pending'
3612           || $previousContributionStatus == 'In Progress')
3613         && ($currentContributionStatus == 'Completed')
3614       ) {
3615         if (empty($params['line_item'])) {
3616           //CRM-15296
3617           //@todo - check with Joe regarding this situation - payment processors create pending transactions with no line items
3618           // when creating recurring membership payment - there are 2 lines to comment out in contributonPageTest if fixed
3619           // & this can be removed
3620           return;
3621         }
3622         // @todo we should stop passing $params by reference - splitting this out would be a step towards that.
3623         // This is an update so original currency if none passed in.
3624         $params['trxnParams']['currency'] = CRM_Utils_Array::value('currency', $params, $params['prevContribution']->currency);
3625
3626         self::recordAlwaysAccountsReceivable($params['trxnParams'], $params);
3627         $trxn = CRM_Core_BAO_FinancialTrxn::create($params['trxnParams']);
3628         // @todo we should stop passing $params by reference - splitting this out would be a step towards that.
3629         $params['entity_id'] = self::$_trxnIDs[] = $trxn->id;
3630         $query = "UPDATE civicrm_financial_item SET status_id = %1 WHERE entity_id = %2 and entity_table = 'civicrm_line_item'";
3631         $sql = "SELECT id, amount FROM civicrm_financial_item WHERE entity_id = %1 and entity_table = 'civicrm_line_item'";
3632
3633         $entityParams = array(
3634           'entity_table' => 'civicrm_financial_item',
3635         );
3636         foreach ($params['line_item'] as $fieldId => $fields) {
3637           foreach ($fields as $fieldValueId => $lineItemDetails) {
3638             $fparams = array(
3639               1 => array(CRM_Core_PseudoConstant::getKey('CRM_Financial_BAO_FinancialItem', 'status_id', 'Paid'), 'Integer'),
3640               2 => array($lineItemDetails['id'], 'Integer'),
3641             );
3642             CRM_Core_DAO::executeQuery($query, $fparams);
3643             $fparams = array(
3644               1 => array($lineItemDetails['id'], 'Integer'),
3645             );
3646             $financialItem = CRM_Core_DAO::executeQuery($sql, $fparams);
3647             while ($financialItem->fetch()) {
3648               $entityParams['entity_id'] = $financialItem->id;
3649               $entityParams['amount'] = $financialItem->amount;
3650               foreach (self::$_trxnIDs as $tID) {
3651                 $entityParams['financial_trxn_id'] = $tID;
3652                 CRM_Financial_BAO_FinancialItem::createEntityTrxn($entityParams);
3653               }
3654             }
3655           }
3656         }
3657         return;
3658       }
3659     }
3660
3661     $trxn = CRM_Core_BAO_FinancialTrxn::create($params['trxnParams']);
3662     // @todo we should stop passing $params by reference - splitting this out would be a step towards that.
3663     $params['entity_id'] = $trxn->id;
3664     if ($context != 'changePaymentInstrument') {
3665       $itemParams['entity_table'] = 'civicrm_line_item';
3666       $trxnIds['id'] = $params['entity_id'];
3667       $previousLineItems = CRM_Price_BAO_LineItem::getLineItemsByContributionID($params['contribution']->id);
3668       foreach ($params['line_item'] as $fieldId => $fields) {
3669         foreach ($fields as $fieldValueId => $lineItemDetails) {
3670           $prevFinancialItem = CRM_Financial_BAO_FinancialItem::getPreviousFinancialItem($lineItemDetails['id']);
3671           $receiveDate = CRM_Utils_Date::isoToMysql($params['prevContribution']->receive_date);
3672           if ($params['contribution']->receive_date) {
3673             $receiveDate = CRM_Utils_Date::isoToMysql($params['contribution']->receive_date);
3674           }
3675
3676           $financialAccount = self::getFinancialAccountForStatusChangeTrxn($params, CRM_Utils_Array::value('financial_account_id', $prevFinancialItem));
3677
3678           $currency = $params['prevContribution']->currency;
3679           // @todo we should stop passing $params by reference - splitting this out would be a step towards that.
3680           if ($params['contribution']->currency) {
3681             $currency = $params['contribution']->currency;
3682           }
3683           $previousLineItemTotal = CRM_Utils_Array::value('line_total', CRM_Utils_Array::value($fieldValueId, $previousLineItems), 0);
3684           $itemParams = array(
3685             'transaction_date' => $receiveDate,
3686             'contact_id' => $params['prevContribution']->contact_id,
3687             'currency' => $currency,
3688             'amount' => self::getFinancialItemAmountFromParams($inputParams, $context, $lineItemDetails, $isARefund, $previousLineItemTotal),
3689             'description' => CRM_Utils_Array::value('description', $prevFinancialItem),
3690             'status_id' => $prevFinancialItem['status_id'],
3691             'financial_account_id' => $financialAccount,
3692             'entity_table' => 'civicrm_line_item',
3693             'entity_id' => $lineItemDetails['id'],
3694           );
3695           $financialItem = CRM_Financial_BAO_FinancialItem::create($itemParams, NULL, $trxnIds);
3696           // @todo we should stop passing $params by reference - splitting this out would be a step towards that.
3697           $params['line_item'][$fieldId][$fieldValueId]['deferred_line_total'] = $itemParams['amount'];
3698           $params['line_item'][$fieldId][$fieldValueId]['financial_item_id'] = $financialItem->id;
3699
3700           if (($lineItemDetails['tax_amount'] && $lineItemDetails['tax_amount'] !== 'null') || ($context == 'changeFinancialType')) {
3701             $invoiceSettings = Civi::settings()->get('contribution_invoice_settings');
3702             $taxTerm = CRM_Utils_Array::value('tax_term', $invoiceSettings);
3703             $taxAmount = (float) $lineItemDetails['tax_amount'];
3704             if ($context == 'changeFinancialType' && $lineItemDetails['tax_amount'] === 'null') {
3705               // reverse the Sale Tax amount if there is no tax rate associated with new Financial Type
3706               $taxAmount = CRM_Utils_Array::value('tax_amount', CRM_Utils_Array::value($fieldValueId, $previousLineItems), 0);
3707             }
3708             elseif ($previousLineItemTotal != $lineItemDetails['line_total']) {
3709               $taxAmount -= CRM_Utils_Array::value('tax_amount', CRM_Utils_Array::value($fieldValueId, $previousLineItems), 0);
3710             }
3711             $itemParams['amount'] = self::getMultiplier($params['contribution']->contribution_status_id, $context) * $taxAmount;
3712             $itemParams['description'] = $taxTerm;
3713             if ($lineItemDetails['financial_type_id']) {
3714               $itemParams['financial_account_id'] = CRM_Contribute_PseudoConstant::getRelationalFinancialAccount(
3715                 $lineItemDetails['financial_type_id'],
3716                 'Sales Tax Account is'
3717               );
3718             }
3719             CRM_Financial_BAO_FinancialItem::create($itemParams, NULL, $trxnIds);
3720           }
3721         }
3722       }
3723     }
3724     if ($context == 'changeFinancialType') {
3725       // @todo we should stop passing $params by reference - splitting this out would be a step towards that.
3726       $params['skipLineItem'] = FALSE;
3727       foreach ($params['line_item'] as &$lineItems) {
3728         foreach ($lineItems as &$line) {
3729           $line['financial_type_id'] = $params['financial_type_id'];
3730         }
3731       }
3732     }
3733
3734     CRM_Core_BAO_FinancialTrxn::createDeferredTrxn(CRM_Utils_Array::value('line_item', $params), $params['contribution'], TRUE, $context);
3735   }
3736
3737   /**
3738    * Is this contribution status a reversal.
3739    *
3740    * If so we would expect to record a negative value in the financial_trxn table.
3741    *
3742    * @param int $status_id
3743    *
3744    * @return bool
3745    */
3746   public static function isContributionStatusNegative($status_id) {
3747     $reversalStatuses = array('Cancelled', 'Chargeback', 'Refunded');
3748     return in_array(CRM_Contribute_PseudoConstant::contributionStatus($status_id, 'name'), $reversalStatuses);
3749   }
3750
3751   /**
3752    * Check status validation on update of a contribution.
3753    *
3754    * @param array $values
3755    *   Previous form values before submit.
3756    *
3757    * @param array $fields
3758    *   The input form values.
3759    *
3760    * @param array $errors
3761    *   List of errors.
3762    *
3763    * @return bool
3764    */
3765   public static function checkStatusValidation($values, &$fields, &$errors) {
3766     if (CRM_Utils_System::isNull($values) && !empty($fields['id'])) {
3767       $values['contribution_status_id'] = CRM_Core_DAO::getFieldValue('CRM_Contribute_DAO_Contribution', $fields['id'], 'contribution_status_id');
3768       if ($values['contribution_status_id'] == $fields['contribution_status_id']) {
3769         return FALSE;
3770       }
3771     }
3772     $contributionStatuses = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
3773     $checkStatus = array(
3774       'Cancelled' => array('Completed', 'Refunded'),
3775       'Completed' => array('Cancelled', 'Refunded', 'Chargeback'),
3776       'Pending' => array('Cancelled', 'Completed', 'Failed', 'Partially paid'),
3777       'In Progress' => array('Cancelled', 'Completed', 'Failed'),
3778       'Refunded' => array('Cancelled', 'Completed'),
3779       'Partially paid' => array('Completed'),
3780     );
3781
3782     if (!in_array($contributionStatuses[$fields['contribution_status_id']],
3783       CRM_Utils_Array::value($contributionStatuses[$values['contribution_status_id']], $checkStatus, array()))
3784     ) {
3785       $errors['contribution_status_id'] = ts("Cannot change contribution status from %1 to %2.", array(
3786         1 => $contributionStatuses[$values['contribution_status_id']],
3787         2 => $contributionStatuses[$fields['contribution_status_id']],
3788       ));
3789     }
3790   }
3791
3792   /**
3793    * Delete contribution of contact.
3794    *
3795    * CRM-12155
3796    *
3797    * @param int $contactId
3798    *   Contact id.
3799    *
3800    */
3801   public static function deleteContactContribution($contactId) {
3802     $contribution = new CRM_Contribute_DAO_Contribution();
3803     $contribution->contact_id = $contactId;
3804     $contribution->find();
3805     while ($contribution->fetch()) {
3806       self::deleteContribution($contribution->id);
3807     }
3808   }
3809
3810   /**
3811    * Get options for a given contribution field.
3812    * @see CRM_Core_DAO::buildOptions
3813    *
3814    * @param string $fieldName
3815    * @param string $context see CRM_Core_DAO::buildOptionsContext.
3816    * @param array $props  whatever is known about this dao object.
3817    *
3818    * @return array|bool
3819    */
3820   public static function buildOptions($fieldName, $context = NULL, $props = array()) {
3821     $className = __CLASS__;
3822     $params = array();
3823     if (isset($props['orderColumn'])) {
3824       $params['orderColumn'] = $props['orderColumn'];
3825     }
3826     switch ($fieldName) {
3827       // This field is not part of this object but the api supports it
3828       case 'payment_processor':
3829         $className = 'CRM_Contribute_BAO_ContributionPage';
3830         // Filter results by contribution page
3831         if (!empty($props['contribution_page_id'])) {
3832           $page = civicrm_api('contribution_page', 'getsingle', array(
3833             'version' => 3,
3834             'id' => ($props['contribution_page_id']),
3835           ));
3836           $types = (array) CRM_Utils_Array::value('payment_processor', $page, 0);
3837           $params['condition'] = 'id IN (' . implode(',', $types) . ')';
3838         }
3839         break;
3840
3841       // CRM-13981 This field was combined with soft_credits in 4.5 but the api still supports it
3842       case 'honor_type_id':
3843         $className = 'CRM_Contribute_BAO_ContributionSoft';
3844         $fieldName = 'soft_credit_type_id';
3845         $params['condition'] = "v.name IN ('in_honor_of','in_memory_of')";
3846         break;
3847     }
3848     return CRM_Core_PseudoConstant::get($className, $fieldName, $params, $context);
3849   }
3850
3851   /**
3852    * Validate financial type.
3853    *
3854    * CRM-13231
3855    *
3856    * @param int $financialTypeId
3857    *   Financial Type id.
3858    *
3859    * @param string $relationName
3860    *
3861    * @return array|bool
3862    */
3863   public static function validateFinancialType($financialTypeId, $relationName = 'Expense Account is') {
3864     $financialAccount = CRM_Contribute_PseudoConstant::getRelationalFinancialAccount($financialTypeId, $relationName);
3865
3866     if (!$financialAccount) {
3867       return CRM_Contribute_PseudoConstant::financialType($financialTypeId);
3868     }
3869     return FALSE;
3870   }
3871
3872
3873   /**
3874    * Function to record additional payment for partial and refund contributions.
3875    *
3876    * @param int $contributionId
3877    *   is the invoice contribution id (got created after processing participant payment).
3878    * @param array $trxnsData
3879    *   to take user provided input of transaction details.
3880    * @param string $paymentType
3881    *   'owed' for purpose of recording partial payments, 'refund' for purpose of recording refund payments.
3882    * @param int $participantId
3883    * @param bool $updateStatus
3884    *
3885    * @return null|object
3886    */
3887   public static function recordAdditionalPayment($contributionId, $trxnsData, $paymentType = 'owed', $participantId = NULL, $updateStatus = TRUE) {
3888
3889     if ($paymentType == 'owed') {
3890       $financialTrxn = CRM_Financial_BAO_Payment::recordPayment($contributionId, $trxnsData, $participantId);
3891     }
3892     elseif ($paymentType == 'refund') {
3893       $financialTrxn = CRM_Financial_BAO_Payment::recordRefundPayment($contributionId, $trxnsData, $updateStatus);
3894       if ($participantId) {
3895         // update participant status
3896         // @todo this doesn't make sense...
3897         $participantStatuses = CRM_Event_PseudoConstant::participantStatus();
3898         $ids = CRM_Event_BAO_Participant::getParticipantIds($contributionId);
3899         foreach ($ids as $val) {
3900           $participantUpdate['id'] = $val;
3901           $participantUpdate['status_id'] = array_search('Registered', $participantStatuses);
3902           CRM_Event_BAO_Participant::add($participantUpdate);
3903         }
3904       }
3905     }
3906
3907     if (!empty($financialTrxn)) {
3908       self::recordPaymentActivity($contributionId, $participantId, $financialTrxn);
3909       return $financialTrxn;
3910     }
3911
3912   }
3913
3914   /**
3915    * @param $entityObj
3916    * @param $trxnObj
3917    * @param $activityType
3918    * @param $component
3919    * @param int $contributionId
3920    *
3921    * @throws CRM_Core_Exception
3922    */
3923   public static function addActivityForPayment($entityObj, $trxnObj, $activityType, $component, $contributionId) {
3924     if ($component == 'event') {
3925       $title = CRM_Core_DAO::getFieldValue('CRM_Event_BAO_Event', $entityObj->event_id, 'title');
3926     }
3927     else {
3928       $title = ts('Contribution');
3929     }
3930     $paymentAmount = CRM_Utils_Money::format($trxnObj->total_amount, $trxnObj->currency);
3931     $subject = "{$paymentAmount} - Offline {$activityType} for {$title}";
3932     $date = CRM_Utils_Date::isoToMysql($trxnObj->trxn_date);
3933     $targetCid = $entityObj->contact_id;
3934     // source record id would be the contribution id
3935     $srcRecId = $contributionId;
3936
3937     // activity params
3938     $activityParams = array(
3939       'source_contact_id' => $targetCid,
3940       'source_record_id' => $srcRecId,
3941       'activity_type_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', $activityType),
3942       'subject' => $subject,
3943       'activity_date_time' => $date,
3944       'status_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_status_id', 'Completed'),
3945       'skipRecentView' => TRUE,
3946     );
3947
3948     // create activity with target contacts
3949     $session = CRM_Core_Session::singleton();
3950     $id = $session->get('userID');
3951     if ($id) {
3952       $activityParams['source_contact_id'] = $id;
3953       $activityParams['target_contact_id'][] = $targetCid;
3954     }
3955     // @todo use api.
3956     CRM_Activity_BAO_Activity::create($activityParams);
3957   }
3958
3959   /**
3960    * Get list of payments displayed by Contribute_Page_PaymentInfo.
3961    *
3962    * @param int $id
3963    * @param $component
3964    * @param bool $getTrxnInfo
3965    * @param bool $usingLineTotal
3966    *
3967    * @return mixed
3968    */
3969   public static function getPaymentInfo($id, $component = 'contribution', $getTrxnInfo = FALSE, $usingLineTotal = FALSE) {
3970     // @todo deprecate passing in component - always call with contribution.
3971     if ($component == 'event') {
3972       $contributionId = CRM_Core_DAO::getFieldValue('CRM_Event_BAO_ParticipantPayment', $id, 'contribution_id', 'participant_id');
3973
3974       if (!$contributionId) {
3975         if ($primaryParticipantId = CRM_Core_DAO::getFieldValue('CRM_Event_BAO_Participant', $id, 'registered_by_id')) {
3976           $contributionId = CRM_Core_DAO::getFieldValue('CRM_Event_BAO_ParticipantPayment', $primaryParticipantId, 'contribution_id', 'participant_id');
3977           $id = $primaryParticipantId;
3978         }
3979         if (!$contributionId) {
3980           return;
3981         }
3982       }
3983     }
3984     elseif ($component == 'membership') {
3985       $contributionId = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_MembershipPayment', $id, 'contribution_id', 'membership_id');
3986     }
3987     else {
3988       $contributionId = $id;
3989     }
3990
3991     $total = CRM_Core_BAO_FinancialTrxn::getBalanceTrxnAmt($contributionId);
3992     $baseTrxnId = !empty($total['trxn_id']) ? $total['trxn_id'] : NULL;
3993     if (!$baseTrxnId) {
3994       $baseTrxnId = CRM_Core_BAO_FinancialTrxn::getFinancialTrxnId($contributionId);
3995       $baseTrxnId = $baseTrxnId['financialTrxnId'];
3996     }
3997     if (!CRM_Utils_Array::value('total_amount', $total) || $usingLineTotal) {
3998       $total = CRM_Price_BAO_LineItem::getLineTotal($contributionId);
3999     }
4000     else {
4001       $baseTrxnId = $total['trxn_id'];
4002       $total = $total['total_amount'];
4003     }
4004
4005     $paymentBalance = CRM_Contribute_BAO_Contribution::getContributionBalance($contributionId, $total);
4006
4007     $contribution = civicrm_api3('Contribution', 'getsingle', array('id' => $contributionId, 'return' => array('currency', 'is_pay_later', 'contribution_status_id', 'financial_type_id')));
4008
4009     $info['payLater'] = $contribution['is_pay_later'];
4010     $info['contribution_status'] = $contribution['contribution_status'];
4011     $info['currency'] = $contribution['currency'];
4012
4013     $financialTypeId = $contribution['financial_type_id'];
4014     $feeFinancialAccount = CRM_Contribute_PseudoConstant::getRelationalFinancialAccount($financialTypeId, 'Expense Account is');
4015
4016     if ($paymentBalance == 0 && $info['payLater']) {
4017       // @todo - review - this looks very unlikely to be correct.
4018       // the balance should be correct based on payment transactions not
4019       // assumptions.
4020       $paymentBalance = $total;
4021     }
4022
4023     $info['total'] = $total;
4024     $info['paid'] = $total - $paymentBalance;
4025     $info['balance'] = $paymentBalance;
4026     $info['id'] = $id;
4027     $info['component'] = $component;
4028     $rows = array();
4029     if ($getTrxnInfo && $baseTrxnId) {
4030       // Need to exclude fee trxn rows so filter out rows where TO FINANCIAL ACCOUNT is expense account
4031       $sql = "
4032         SELECT GROUP_CONCAT(fa.`name`) as financial_account,
4033           ft.total_amount,
4034           ft.payment_instrument_id,
4035           ft.trxn_date, ft.trxn_id, ft.status_id, ft.check_number, ft.currency, ft.pan_truncation, ft.card_type_id, ft.id
4036
4037         FROM civicrm_contribution con
4038           LEFT JOIN civicrm_entity_financial_trxn eft ON (eft.entity_id = con.id AND eft.entity_table = 'civicrm_contribution')
4039           INNER JOIN civicrm_financial_trxn ft ON ft.id = eft.financial_trxn_id
4040             AND ft.to_financial_account_id != %2
4041           LEFT JOIN civicrm_entity_financial_trxn ef ON (ef.financial_trxn_id = ft.id AND ef.entity_table = 'civicrm_financial_item')
4042           LEFT JOIN civicrm_financial_item fi ON fi.id = ef.entity_id
4043           LEFT JOIN civicrm_financial_account fa ON fa.id = fi.financial_account_id
4044
4045         WHERE con.id = %1 AND ft.is_payment = 1
4046         GROUP BY ft.id";
4047       $queryParams = array(
4048         1 => array($contributionId, 'Integer'),
4049         2 => array($feeFinancialAccount, 'Integer'),
4050       );
4051       $resultDAO = CRM_Core_DAO::executeQuery($sql, $queryParams);
4052       $statuses = CRM_Contribute_PseudoConstant::contributionStatus();
4053
4054       while ($resultDAO->fetch()) {
4055         $paidByLabel = CRM_Core_PseudoConstant::getLabel('CRM_Core_BAO_FinancialTrxn', 'payment_instrument_id', $resultDAO->payment_instrument_id);
4056         $paidByName = CRM_Core_PseudoConstant::getName('CRM_Core_BAO_FinancialTrxn', 'payment_instrument_id', $resultDAO->payment_instrument_id);
4057         if ($resultDAO->card_type_id) {
4058           $creditCardType = CRM_Core_PseudoConstant::getLabel('CRM_Core_BAO_FinancialTrxn', 'card_type_id', $resultDAO->card_type_id);
4059           $pantruncation = '';
4060           if ($resultDAO->pan_truncation) {
4061             $pantruncation = ": {$resultDAO->pan_truncation}";
4062           }
4063           $paidByLabel .= " ({$creditCardType}{$pantruncation})";
4064         }
4065
4066         // show payment edit link only for payments done via backoffice form
4067         $paymentEditLink = '';
4068         if (empty($resultDAO->payment_processor_id) && CRM_Core_Permission::check('edit contributions')) {
4069           $links = array(
4070             CRM_Core_Action::UPDATE => array(
4071               'name' => "<i class='crm-i fa-pencil'></i>",
4072               'url' => 'civicrm/payment/edit',
4073               'class' => 'medium-popup',
4074               'qs' => "reset=1&id=%%id%%&contribution_id=%%contribution_id%%",
4075               'title' => ts('Edit Payment'),
4076             ),
4077           );
4078           $paymentEditLink = CRM_Core_Action::formLink(
4079             $links,
4080             CRM_Core_Action::mask(array(CRM_Core_Permission::EDIT)),
4081             array(
4082               'id' => $resultDAO->id,
4083               'contribution_id' => $contributionId,
4084             )
4085           );
4086         }
4087
4088         $val = array(
4089           'id' => $resultDAO->id,
4090           'total_amount' => $resultDAO->total_amount,
4091           'financial_type' => $resultDAO->financial_account,
4092           'payment_instrument' => $paidByLabel,
4093           'receive_date' => $resultDAO->trxn_date,
4094           'trxn_id' => $resultDAO->trxn_id,
4095           'status' => $statuses[$resultDAO->status_id],
4096           'currency' => $resultDAO->currency,
4097           'action' => $paymentEditLink,
4098         );
4099         if ($paidByName == 'Check') {
4100           $val['check_number'] = $resultDAO->check_number;
4101         }
4102         $rows[] = $val;
4103       }
4104       $info['transaction'] = $rows;
4105     }
4106
4107     $info['payment_links'] = self::getContributionPaymentLinks($id, $paymentBalance, $info['contribution_status']);
4108     return $info;
4109   }
4110
4111   /**
4112    * Get the outstanding balance on a contribution.
4113    *
4114    * @param int $contributionId
4115    * @param float $contributionTotal
4116    *   Optional amount to override the saved amount paid (e.g if calculating what it WILL be).
4117    *
4118    * @return float
4119    */
4120   public static function getContributionBalance($contributionId, $contributionTotal = NULL) {
4121     if ($contributionTotal === NULL) {
4122       $contributionTotal = CRM_Price_BAO_LineItem::getLineTotal($contributionId);
4123     }
4124
4125     return CRM_Utils_Money::subtractCurrencies(
4126       $contributionTotal,
4127       CRM_Core_BAO_FinancialTrxn::getTotalPayments($contributionId, TRUE) ?: 0,
4128       CRM_Core_DAO::getFieldValue('CRM_Contribute_DAO_Contribution', $contributionId, 'currency')
4129     );
4130   }
4131
4132   /**
4133    * Get the tax amount (misnamed function).
4134    *
4135    * @param array $params
4136    * @param bool $isLineItem
4137    *
4138    * @return array
4139    */
4140   public static function checkTaxAmount($params, $isLineItem = FALSE) {
4141     $taxRates = CRM_Core_PseudoConstant::getTaxRates();
4142
4143     // This function should be only called after standardisation (removal of
4144     // thousand separator & using a decimal point for cents separator.
4145     // However, we don't know if that is always true :-(
4146     // There is a deprecation notice tho :-)
4147     $unknownIfMoneyIsClean = empty($params['skipCleanMoney']) && !$isLineItem;
4148     // Update contribution.
4149     if (!empty($params['id'])) {
4150       // CRM-19126 and CRM-19152 If neither total or financial_type_id are set on an update
4151       // there are no tax implications - early return.
4152       if (!isset($params['total_amount']) && !isset($params['financial_type_id'])) {
4153         return $params;
4154       }
4155       if (empty($params['prevContribution'])) {
4156         $params['prevContribution'] = self::getOriginalContribution($params['id']);
4157       }
4158
4159       foreach (array('total_amount', 'financial_type_id', 'fee_amount') as $field) {
4160         if (!isset($params[$field])) {
4161           if ($field == 'total_amount' && $params['prevContribution']->tax_amount) {
4162             // Tax amount gets added back on later....
4163             $params['total_amount'] = $params['prevContribution']->total_amount -
4164               $params['prevContribution']->tax_amount;
4165           }
4166           else {
4167             $params[$field] = $params['prevContribution']->$field;
4168             if ($params[$field] != $params['prevContribution']->$field) {
4169             }
4170           }
4171         }
4172       }
4173
4174       self::calculateMissingAmountParams($params, $params['id']);
4175       if (!array_key_exists($params['financial_type_id'], $taxRates)) {
4176         // Assign tax Amount on update of contribution
4177         if (!empty($params['prevContribution']->tax_amount)) {
4178           $params['tax_amount'] = 'null';
4179           CRM_Price_BAO_LineItem::getLineItemArray($params, array($params['id']));
4180           foreach ($params['line_item'] as $setID => $priceField) {
4181             foreach ($priceField as $priceFieldID => $priceFieldValue) {
4182               $params['line_item'][$setID][$priceFieldID]['tax_amount'] = $params['tax_amount'];
4183             }
4184           }
4185         }
4186       }
4187     }
4188
4189     // New Contribution and update of contribution with tax rate financial type
4190     if (isset($params['financial_type_id']) && array_key_exists($params['financial_type_id'], $taxRates) &&
4191       empty($params['skipLineItem']) && !$isLineItem
4192     ) {
4193       $taxRateParams = $taxRates[$params['financial_type_id']];
4194       $taxAmount = CRM_Contribute_BAO_Contribution_Utils::calculateTaxAmount(CRM_Utils_Array::value('total_amount', $params), $taxRateParams, $unknownIfMoneyIsClean);
4195       $params['tax_amount'] = round($taxAmount['tax_amount'], 2);
4196
4197       // Get Line Item on update of contribution
4198       if (isset($params['id'])) {
4199         CRM_Price_BAO_LineItem::getLineItemArray($params, array($params['id']));
4200       }
4201       else {
4202         CRM_Price_BAO_LineItem::getLineItemArray($params);
4203       }
4204       foreach ($params['line_item'] as $setID => $priceField) {
4205         foreach ($priceField as $priceFieldID => $priceFieldValue) {
4206           $params['line_item'][$setID][$priceFieldID]['tax_amount'] = $params['tax_amount'];
4207         }
4208       }
4209       $params['total_amount'] = CRM_Utils_Array::value('total_amount', $params) + $params['tax_amount'];
4210     }
4211     elseif (isset($params['api.line_item.create'])) {
4212       // Update total amount of contribution using lineItem
4213       $taxAmountArray = array();
4214       foreach ($params['api.line_item.create'] as $key => $value) {
4215         if (isset($value['financial_type_id']) && array_key_exists($value['financial_type_id'], $taxRates)) {
4216           $taxRate = $taxRates[$value['financial_type_id']];
4217           $taxAmount = CRM_Contribute_BAO_Contribution_Utils::calculateTaxAmount($value['line_total'], $taxRate);
4218           $taxAmountArray[] = round($taxAmount['tax_amount'], 2);
4219         }
4220       }
4221       $params['tax_amount'] = array_sum($taxAmountArray);
4222       $params['total_amount'] = $params['total_amount'] + $params['tax_amount'];
4223     }
4224     else {
4225       // update line item of contrbution
4226       if (isset($params['financial_type_id']) && array_key_exists($params['financial_type_id'], $taxRates)  && $isLineItem) {
4227         $taxRate = $taxRates[$params['financial_type_id']];
4228         $taxAmount = CRM_Contribute_BAO_Contribution_Utils::calculateTaxAmount($params['line_total'], $taxRate, $unknownIfMoneyIsClean);
4229         $params['tax_amount'] = round($taxAmount['tax_amount'], 2);
4230       }
4231     }
4232     return $params;
4233   }
4234
4235   /**
4236    * Check financial type validation on update of a contribution.
4237    *
4238    * @param Integer $financialTypeId
4239    *   Value of latest Financial Type.
4240    *
4241    * @param Integer $contributionId
4242    *   Contribution Id.
4243    *
4244    * @param array $errors
4245    *   List of errors.
4246    *
4247    * @return void
4248    */
4249   public static function checkFinancialTypeChange($financialTypeId, $contributionId, &$errors) {
4250     if (!empty($financialTypeId)) {
4251       $oldFinancialTypeId = CRM_Core_DAO::getFieldValue('CRM_Contribute_DAO_Contribution', $contributionId, 'financial_type_id');
4252       if ($oldFinancialTypeId == $financialTypeId) {
4253         return;
4254       }
4255     }
4256     $sql = 'SELECT financial_type_id FROM civicrm_line_item WHERE contribution_id = %1 GROUP BY financial_type_id;';
4257     $params = array(
4258       '1' => array($contributionId, 'Integer'),
4259     );
4260     $result = CRM_Core_DAO::executeQuery($sql, $params);
4261     if ($result->N > 1) {
4262       $errors['financial_type_id'] = ts('One or more line items have a different financial type than the contribution. Editing the financial type is not yet supported in this situation.');
4263     }
4264   }
4265
4266   /**
4267    * Update related pledge payment payments.
4268    *
4269    * This function has been refactored out of the back office contribution form and may
4270    * still overlap with other functions.
4271    *
4272    * @param string $action
4273    * @param int $pledgePaymentID
4274    * @param int $contributionID
4275    * @param bool $adjustTotalAmount
4276    * @param float $total_amount
4277    * @param float $original_total_amount
4278    * @param int $contribution_status_id
4279    * @param int $original_contribution_status_id
4280    */
4281   public static function updateRelatedPledge(
4282     $action,
4283     $pledgePaymentID,
4284     $contributionID,
4285     $adjustTotalAmount,
4286     $total_amount,
4287     $original_total_amount,
4288     $contribution_status_id,
4289     $original_contribution_status_id
4290   ) {
4291     if (!$pledgePaymentID && $action & CRM_Core_Action::ADD && !$contributionID) {
4292       return;
4293     }
4294
4295     if ($pledgePaymentID) {
4296       //store contribution id in payment record.
4297       CRM_Core_DAO::setFieldValue('CRM_Pledge_DAO_PledgePayment', $pledgePaymentID, 'contribution_id', $contributionID);
4298     }
4299     else {
4300       $pledgePaymentID = CRM_Core_DAO::getFieldValue('CRM_Pledge_DAO_PledgePayment',
4301         $contributionID,
4302         'id',
4303         'contribution_id'
4304       );
4305     }
4306
4307     if (!$pledgePaymentID) {
4308       return;
4309     }
4310     $pledgeID = CRM_Core_DAO::getFieldValue('CRM_Pledge_DAO_PledgePayment',
4311       $contributionID,
4312       'pledge_id',
4313       'contribution_id'
4314     );
4315
4316     $updatePledgePaymentStatus = FALSE;
4317
4318     // If either the status or the amount has changed we update the pledge status.
4319     if ($action & CRM_Core_Action::ADD) {
4320       $updatePledgePaymentStatus = TRUE;
4321     }
4322     elseif ($action & CRM_Core_Action::UPDATE && (($original_contribution_status_id != $contribution_status_id) ||
4323         ($original_total_amount != $total_amount))
4324     ) {
4325       $updatePledgePaymentStatus = TRUE;
4326     }
4327
4328     if ($updatePledgePaymentStatus) {
4329       CRM_Pledge_BAO_PledgePayment::updatePledgePaymentStatus($pledgeID,
4330         array($pledgePaymentID),
4331         $contribution_status_id,
4332         NULL,
4333         $total_amount,
4334         $adjustTotalAmount
4335       );
4336     }
4337   }
4338
4339   /**
4340    * Compute the stats values
4341    *
4342    * @deprecated
4343    *
4344    * @param string $stat either 'mode' or 'median'
4345    * @param string $sql
4346    * @param string $alias of civicrm_contribution
4347    *
4348    * @return array|null
4349    */
4350   public static function computeStats($stat, $sql, $alias = NULL) {
4351     CRM_Core_Error::deprecatedFunctionWarning('computeStats is now deprecated');
4352     return [];
4353   }
4354
4355   /**
4356    * Is there only one line item attached to the contribution.
4357    *
4358    * @param int $id
4359    *   Contribution ID.
4360    *
4361    * @return bool
4362    * @throws \CiviCRM_API3_Exception
4363    */
4364   public static function isSingleLineItem($id) {
4365     $lineItemCount = civicrm_api3('LineItem', 'getcount', array('contribution_id' => $id));
4366     return ($lineItemCount == 1);
4367   }
4368
4369   /**
4370    * Complete an order.
4371    *
4372    * Do not call this directly - use the contribution.completetransaction api as this function is being refactored.
4373    *
4374    * Currently overloaded to complete a transaction & repeat a transaction - fix!
4375    *
4376    * Moving it out of the BaseIPN class is just the first step.
4377    *
4378    * @param array $input
4379    * @param array $ids
4380    * @param array $objects
4381    * @param CRM_Core_Transaction $transaction
4382    * @param int $recur
4383    * @param CRM_Contribute_BAO_Contribution $contribution
4384    *
4385    * @return array
4386    */
4387   public static function completeOrder(&$input, &$ids, $objects, $transaction, $recur, $contribution) {
4388     $primaryContributionID = isset($contribution->id) ? $contribution->id : $objects['first_contribution']->id;
4389     // The previous details are used when calculating line items so keep it before any code that 'does something'
4390     if (!empty($contribution->id)) {
4391       $input['prevContribution'] = CRM_Contribute_BAO_Contribution::getValues(array('id' => $contribution->id),
4392         CRM_Core_DAO::$_nullArray, CRM_Core_DAO::$_nullArray);
4393     }
4394     $inputContributionWhiteList = array(
4395       'fee_amount',
4396       'net_amount',
4397       'trxn_id',
4398       'check_number',
4399       'payment_instrument_id',
4400       'is_test',
4401       'campaign_id',
4402       'receive_date',
4403       'receipt_date',
4404       'contribution_status_id',
4405       'card_type_id',
4406       'pan_truncation',
4407     );
4408     if (self::isSingleLineItem($primaryContributionID)) {
4409       $inputContributionWhiteList[] = 'financial_type_id';
4410     }
4411
4412     $participant = CRM_Utils_Array::value('participant', $objects);
4413     $recurContrib = CRM_Utils_Array::value('contributionRecur', $objects);
4414     $recurringContributionID = (empty($recurContrib->id)) ? NULL : $recurContrib->id;
4415     $event = CRM_Utils_Array::value('event', $objects);
4416
4417     $paymentProcessorId = '';
4418     if (isset($objects['paymentProcessor'])) {
4419       if (is_array($objects['paymentProcessor'])) {
4420         $paymentProcessorId = $objects['paymentProcessor']['id'];
4421       }
4422       else {
4423         $paymentProcessorId = $objects['paymentProcessor']->id;
4424       }
4425     }
4426
4427     $completedContributionStatusID = CRM_Core_PseudoConstant::getKey('CRM_Contribute_BAO_Contribution', 'contribution_status_id', 'Completed');
4428
4429     $contributionParams = array_merge(array(
4430       'contribution_status_id' => $completedContributionStatusID,
4431       'source' => self::getRecurringContributionDescription($contribution, $event),
4432     ), array_intersect_key($input, array_fill_keys($inputContributionWhiteList, 1)
4433     ));
4434
4435     // CRM-20678 Ensure that the currency is correct in subseqent transcations.
4436     if (empty($contributionParams['currency']) && isset($objects['first_contribution']->currency)) {
4437       $contributionParams['currency'] = $objects['first_contribution']->currency;
4438     }
4439
4440     $contributionParams['payment_processor'] = $input['payment_processor'] = $paymentProcessorId;
4441
4442     // If paymentProcessor is not set then the payment_instrument_id would not be correct.
4443     // not clear when or if this would occur if you encounter this please fix here & add a unit test.
4444     if (empty($contributionParams['payment_instrument_id']) && isset($contribution->_relatedObjects['paymentProcessor']['payment_instrument_id'])) {
4445       $contributionParams['payment_instrument_id'] = $contribution->_relatedObjects['paymentProcessor']['payment_instrument_id'];
4446     }
4447
4448     if ($recurringContributionID) {
4449       $contributionParams['contribution_recur_id'] = $recurringContributionID;
4450     }
4451     $changeDate = CRM_Utils_Array::value('trxn_date', $input, date('YmdHis'));
4452
4453     if (empty($contributionParams['receive_date']) && $changeDate) {
4454       $contributionParams['receive_date'] = $changeDate;
4455     }
4456
4457     self::repeatTransaction($contribution, $input, $contributionParams, $paymentProcessorId);
4458     $contributionParams['financial_type_id'] = $contribution->financial_type_id;
4459
4460     $values = array();
4461     if (isset($input['is_email_receipt'])) {
4462       $values['is_email_receipt'] = $input['is_email_receipt'];
4463     }
4464
4465     if ($input['component'] == 'contribute') {
4466       if ($contribution->contribution_page_id) {
4467         // Figure out what we gain from this.
4468         // Note that we may have overwritten the is_email_receipt input, fix that below.
4469         CRM_Contribute_BAO_ContributionPage::setValues($contribution->contribution_page_id, $values);
4470       }
4471       elseif ($recurContrib && $recurringContributionID) {
4472         $values['amount'] = $recurContrib->amount;
4473         $values['financial_type_id'] = $objects['contributionType']->id;
4474         $values['title'] = $source = ts('Offline Recurring Contribution');
4475       }
4476
4477       if (isset($input['is_email_receipt'])) {
4478         // CRM-19601 - we may have overwritten this above.
4479         $values['is_email_receipt'] = $input['is_email_receipt'];
4480       }
4481       elseif ($recurContrib && $recurringContributionID) {
4482         //CRM-13273 - is_email_receipt setting on recurring contribution should take precedence over contribution page setting
4483         // but CRM-16124 if $input['is_email_receipt'] is set then that should not be overridden.
4484         $values['is_email_receipt'] = $recurContrib->is_email_receipt;
4485       }
4486
4487       if ($contributionParams['contribution_status_id'] === $completedContributionStatusID) {
4488         self::updateMembershipBasedOnCompletionOfContribution(
4489           $contribution,
4490           $primaryContributionID,
4491           $changeDate
4492         );
4493       }
4494     }
4495     else {
4496       if (empty($input['IAmAHorribleNastyBeyondExcusableHackInTheCRMEventFORMTaskClassThatNeedsToBERemoved'])) {
4497         if ($event->is_email_confirm) {
4498           // @todo this should be set by the function that sends the mail after sending.
4499           $contributionParams['receipt_date'] = $changeDate;
4500         }
4501         $participantParams['id'] = $participant->id;
4502         $participantParams['status_id'] = 'Registered';
4503         civicrm_api3('Participant', 'create', $participantParams);
4504       }
4505     }
4506
4507     $contributionParams['id'] = $contribution->id;
4508
4509     // CRM-19309 - if you update the contribution here with financial_type_id it can/will mess with $lineItem
4510     // unsetting it here does NOT cause any other contribution test to fail!
4511     unset($contributionParams['financial_type_id']);
4512     $contributionResult = civicrm_api3('Contribution', 'create', $contributionParams);
4513
4514     // Add new soft credit against current $contribution.
4515     if (CRM_Utils_Array::value('contributionRecur', $objects) && $objects['contributionRecur']->id) {
4516       CRM_Contribute_BAO_ContributionRecur::addrecurSoftCredit($objects['contributionRecur']->id, $contribution->id);
4517     }
4518
4519     $contributionStatuses = CRM_Core_PseudoConstant::get('CRM_Contribute_DAO_Contribution', 'contribution_status_id', array(
4520       'labelColumn' => 'name',
4521       'flip' => 1,
4522     ));
4523     if (isset($input['prevContribution']) && (!$input['prevContribution']->is_pay_later && $input['prevContribution']->contribution_status_id == $contributionStatuses['Pending'])) {
4524       $input['payment_processor'] = $paymentProcessorId;
4525     }
4526
4527     if (!empty($contribution->_relatedObjects['participant'])) {
4528       $input['contribution_mode'] = 'participant';
4529       $input['participant_id'] = $contribution->_relatedObjects['participant']->id;
4530     }
4531     elseif (!empty($contribution->_relatedObjects['membership'])) {
4532       // @todo - use getRelatedMemberships instead
4533       $input['contribution_mode'] = 'membership';
4534       $contribution->contribution_status_id = $contributionParams['contribution_status_id'];
4535       $contribution->trxn_id = CRM_Utils_Array::value('trxn_id', $input);
4536       $contribution->receive_date = CRM_Utils_Date::isoToMysql($contribution->receive_date);
4537     }
4538
4539     CRM_Core_Error::debug_log_message("Contribution record updated successfully");
4540     $transaction->commit();
4541
4542     CRM_Contribute_BAO_ContributionRecur::updateRecurLinkedPledge($contribution->id, $recurringContributionID,
4543       $contributionParams['contribution_status_id'], $input['amount']);
4544
4545     // create an activity record
4546     if ($input['component'] == 'contribute') {
4547       //CRM-4027
4548       $targetContactID = NULL;
4549       if (!empty($ids['related_contact'])) {
4550         $targetContactID = $contribution->contact_id;
4551         $contribution->contact_id = $ids['related_contact'];
4552       }
4553       CRM_Activity_BAO_Activity::addActivity($contribution, NULL, $targetContactID);
4554     }
4555
4556     // CRM-9132 legacy behaviour was that receipts were sent out in all instances. Still sending
4557     // when array_key 'is_email_receipt doesn't exist in case some instances where is needs setting haven't been set
4558     if (!array_key_exists('is_email_receipt', $values) ||
4559       $values['is_email_receipt'] == 1
4560     ) {
4561       civicrm_api3('Contribution', 'sendconfirmation', array(
4562         'id' => $contribution->id,
4563         'payment_processor_id' => $paymentProcessorId,
4564       ));
4565       CRM_Core_Error::debug_log_message("Receipt sent");
4566     }
4567
4568     CRM_Core_Error::debug_log_message("Success: Database updated");
4569     return $contributionResult;
4570   }
4571
4572   /**
4573    * Send receipt from contribution.
4574    *
4575    * Do not call this directly - it is being refactored. use contribution.sendmessage api call.
4576    *
4577    * Note that the compose message part has been moved to contribution
4578    * In general LoadObjects is called first to get the objects but the composeMessageArray function now calls it.
4579    *
4580    * @param array $input
4581    *   Incoming data from Payment processor.
4582    * @param array $ids
4583    *   Related object IDs.
4584    * @param int $contributionID
4585    * @param array $values
4586    *   Values related to objects that have already been loaded.
4587    * @param bool $returnMessageText
4588    *   Should text be returned instead of sent. This.
4589    *   is because the function is also used to generate pdfs
4590    *
4591    * @return array
4592    * @throws \CRM_Core_Exception
4593    * @throws \CiviCRM_API3_Exception
4594    */
4595   public static function sendMail(&$input, &$ids, $contributionID, &$values,
4596                                   $returnMessageText = FALSE) {
4597
4598     $contribution = new CRM_Contribute_BAO_Contribution();
4599     $contribution->id = $contributionID;
4600     if (!$contribution->find(TRUE)) {
4601       throw new CRM_Core_Exception('Contribution does not exist');
4602     }
4603     $contribution->loadRelatedObjects($input, $ids, TRUE);
4604     // set receipt from e-mail and name in value
4605     if (!$returnMessageText) {
4606       list($values['receipt_from_name'], $values['receipt_from_email']) = self::generateFromEmailAndName($input, $contribution);
4607     }
4608     $values['contribution_status'] = CRM_Core_PseudoConstant::getLabel('CRM_Contribute_BAO_Contribution', 'contribution_status_id', $contribution->contribution_status_id);
4609     $return = $contribution->composeMessageArray($input, $ids, $values, $returnMessageText);
4610     if ((!isset($input['receipt_update']) || $input['receipt_update']) && empty($contribution->receipt_date)) {
4611       civicrm_api3('Contribution', 'create', array('receipt_date' => 'now', 'id' => $contribution->id));
4612     }
4613     return $return;
4614   }
4615
4616   /**
4617    * Generate From email and from name in an array values
4618    * @param array $input
4619    * @param \CRM_Contribute_BAO_Contribution $contribution
4620    * @return array
4621    */
4622   public static function generateFromEmailAndName($input, $contribution) {
4623     // Use input value if supplied.
4624     if (!empty($input['receipt_from_email'])) {
4625       return array(CRM_Utils_array::value('receipt_from_name', $input, ''), $input['receipt_from_email']);
4626     }
4627     // if we are still empty see if we can use anything from a contribution page.
4628     $pageValues = array();
4629     if (!empty($contribution->contribution_page_id)) {
4630       $pageValues = civicrm_api3('ContributionPage', 'getsingle', array('id' => $contribution->contribution_page_id));
4631     }
4632     // if we are still empty see if we can use anything from a contribution page.
4633     if (!empty($pageValues['receipt_from_email'])) {
4634       return array($pageValues['receipt_from_name'], $pageValues['receipt_from_email']);
4635     }
4636     // If we are still empty fall back to the domain or logged in user information.
4637     return CRM_Core_BAO_Domain::getDefaultReceiptFrom();
4638   }
4639
4640   /**
4641    * Generate credit note id with next avaible number
4642    *
4643    * @return string
4644    *   Credit Note Id.
4645    */
4646   public static function createCreditNoteId() {
4647     $prefixValue = Civi::settings()->get('contribution_invoice_settings');
4648
4649     $creditNoteNum = CRM_Core_DAO::singleValueQuery("SELECT count(creditnote_id) as creditnote_number FROM civicrm_contribution WHERE creditnote_id IS NOT NULL");
4650     $creditNoteId = NULL;
4651
4652     do {
4653       $creditNoteNum++;
4654       $creditNoteId = CRM_Utils_Array::value('credit_notes_prefix', $prefixValue) . "" . $creditNoteNum;
4655       $result = civicrm_api3('Contribution', 'getcount', array(
4656         'sequential' => 1,
4657         'creditnote_id' => $creditNoteId,
4658       ));
4659     } while ($result > 0);
4660
4661     return $creditNoteId;
4662   }
4663
4664   /**
4665    * Load related memberships.
4666    *
4667    * @deprecated
4668    *
4669    * Note that in theory it should be possible to retrieve these from the line_item table
4670    * with the membership_payment table being deprecated. Attempting to do this here causes tests to fail
4671    * as it seems the api is not correctly linking the line items when the contribution is created in the flow
4672    * where the contribution is created in the API, followed by the membership (using the api) followed by the membership
4673    * payment. The membership payment BAO does have code to address this but it doesn't appear to be working.
4674    *
4675    * I don't know if it never worked or broke as a result of https://issues.civicrm.org/jira/browse/CRM-14918.
4676    *
4677    * @param array $ids
4678    *
4679    * @return array $ids
4680    *
4681    * @throws Exception
4682    */
4683   public function loadRelatedMembershipObjects($ids = []) {
4684     $query = "
4685       SELECT membership_id
4686       FROM   civicrm_membership_payment
4687       WHERE  contribution_id = %1 ";
4688     $params = array(1 => array($this->id, 'Integer'));
4689     $ids['membership'] = (array) CRM_Utils_Array::value('membership', $ids, array());
4690
4691     $dao = CRM_Core_DAO::executeQuery($query, $params);
4692     while ($dao->fetch()) {
4693       if ($dao->membership_id && !in_array($dao->membership_id, $ids['membership'])) {
4694         $ids['membership'][$dao->membership_id] = $dao->membership_id;
4695       }
4696     }
4697
4698     if (array_key_exists('membership', $ids) && is_array($ids['membership'])) {
4699       foreach ($ids['membership'] as $id) {
4700         if (!empty($id)) {
4701           $membership = new CRM_Member_BAO_Membership();
4702           $membership->id = $id;
4703           if (!$membership->find(TRUE)) {
4704             throw new Exception("Could not find membership record: $id");
4705           }
4706           $membership->join_date = CRM_Utils_Date::isoToMysql($membership->join_date);
4707           $membership->start_date = CRM_Utils_Date::isoToMysql($membership->start_date);
4708           $membership->end_date = CRM_Utils_Date::isoToMysql($membership->end_date);
4709           $this->_relatedObjects['membership'][$membership->membership_type_id] = $membership;
4710         }
4711       }
4712     }
4713     return $ids;
4714   }
4715
4716   /**
4717    * This function is used to record partial payments for contribution
4718    *
4719    * @param array $contribution
4720    *
4721    * @param array $params
4722    *
4723    * @return CRM_Financial_DAO_FinancialTrxn
4724    */
4725   public static function recordPartialPayment($contribution, $params) {
4726
4727     $balanceTrxnParams['to_financial_account_id'] = self::getToFinancialAccount($contribution, $params);
4728     $balanceTrxnParams['from_financial_account_id'] = CRM_Financial_BAO_FinancialAccount::getFinancialAccountForFinancialTypeByRelationship($contribution['financial_type_id'], 'Accounts Receivable Account is');
4729     $balanceTrxnParams['total_amount'] = $params['total_amount'];
4730     $balanceTrxnParams['contribution_id'] = $params['contribution_id'];
4731     $balanceTrxnParams['trxn_date'] = CRM_Utils_Array::value('trxn_date', $params, CRM_Utils_Array::value('contribution_receive_date', $params, date('YmdHis')));
4732     $balanceTrxnParams['fee_amount'] = CRM_Utils_Array::value('fee_amount', $params);
4733     $balanceTrxnParams['net_amount'] = CRM_Utils_Array::value('total_amount', $params);
4734     $balanceTrxnParams['currency'] = $contribution['currency'];
4735     $balanceTrxnParams['trxn_id'] = CRM_Utils_Array::value('contribution_trxn_id', $params, NULL);
4736     $balanceTrxnParams['status_id'] = CRM_Core_PseudoConstant::getKey('CRM_Core_BAO_FinancialTrxn', 'status_id', 'Completed');
4737     $balanceTrxnParams['payment_instrument_id'] = CRM_Utils_Array::value('payment_instrument_id', $params, $contribution['payment_instrument_id']);
4738     $balanceTrxnParams['check_number'] = CRM_Utils_Array::value('check_number', $params);
4739     $balanceTrxnParams['is_payment'] = 1;
4740
4741     if (!empty($params['payment_processor'])) {
4742       // I can't find evidence this is passed in - I was gonna just remove it but decided to deprecate  as I see self::getToFinancialAccount
4743       // also anticipates it.
4744       CRM_Core_Error::deprecatedFunctionWarning('passing payment_processor is deprecated - use payment_processor_id');
4745       $balanceTrxnParams['payment_processor_id'] = $params['payment_processor'];
4746     }
4747     return CRM_Core_BAO_FinancialTrxn::create($balanceTrxnParams);
4748   }
4749
4750   /**
4751    * Get the description (source field) for the recurring contribution.
4752    *
4753    * @param CRM_Contribute_BAO_Contribution $contribution
4754    * @param CRM_Event_DAO_Event|null $event
4755    *
4756    * @return string
4757    * @throws \CiviCRM_API3_Exception
4758    */
4759   protected static function getRecurringContributionDescription($contribution, $event) {
4760     if (!empty($contribution->source)) {
4761       return $contribution->source;
4762     }
4763     elseif (!empty($contribution->contribution_page_id) && is_numeric($contribution->contribution_page_id)) {
4764       $contributionPageTitle = civicrm_api3('ContributionPage', 'getvalue', array(
4765         'id' => $contribution->contribution_page_id,
4766         'return' => 'title',
4767       ));
4768       return ts('Online Contribution') . ': ' . $contributionPageTitle;
4769     }
4770     elseif ($event) {
4771       return ts('Online Event Registration') . ': ' . $event->title;
4772     }
4773     elseif (!empty($contribution->contribution_recur_id)) {
4774       return 'recurring contribution';
4775     }
4776     return '';
4777   }
4778
4779   /**
4780    * Function to add payments for contribution
4781    * for Partially Paid status
4782    *
4783    * @param array $contributions
4784    * @param string $contributionStatusId
4785    *
4786    */
4787   public static function addPayments($contributions, $contributionStatusId = NULL) {
4788     // get financial trxn which is a payment
4789     $ftSql = "SELECT ft.id, ft.total_amount
4790       FROM civicrm_financial_trxn ft
4791       INNER JOIN civicrm_entity_financial_trxn eft ON eft.financial_trxn_id = ft.id AND eft.entity_table = 'civicrm_contribution'
4792       WHERE eft.entity_id = %1 AND ft.is_payment = 1 ORDER BY ft.id DESC LIMIT 1";
4793     $contributionStatus = CRM_Core_PseudoConstant::get('CRM_Contribute_DAO_Contribution', 'contribution_status_id', array(
4794       'labelColumn' => 'name',
4795     ));
4796     foreach ($contributions as $contribution) {
4797       if (!($contributionStatus[$contribution->contribution_status_id] == 'Partially paid'
4798         || CRM_Utils_Array::value($contributionStatusId, $contributionStatus) == 'Partially paid')
4799       ) {
4800         continue;
4801       }
4802       $ftDao = CRM_Core_DAO::executeQuery($ftSql, array(1 => array($contribution->id, 'Integer')));
4803       $ftDao->fetch();
4804
4805       // store financial item Proportionaly.
4806       $trxnParams = array(
4807         'total_amount' => $ftDao->total_amount,
4808         'contribution_id' => $contribution->id,
4809       );
4810       self::assignProportionalLineItems($trxnParams, $ftDao->id, $contribution->total_amount);
4811     }
4812   }
4813
4814   /**
4815    * Function use to store line item proportionaly in
4816    * in entity financial trxn table
4817    *
4818    * @param array $trxnParams
4819    *
4820    * @param Integer $trxnId
4821    *
4822    * @param float $contributionTotalAmount
4823    *
4824    */
4825   public static function assignProportionalLineItems($trxnParams, $trxnId, $contributionTotalAmount) {
4826     $lineItems = CRM_Price_BAO_LineItem::getLineItemsByContributionID($trxnParams['contribution_id']);
4827     if (!empty($lineItems)) {
4828       // get financial item
4829       list($ftIds, $taxItems) = self::getLastFinancialItemIds($trxnParams['contribution_id']);
4830       $entityParams = array(
4831         'contribution_total_amount' => $contributionTotalAmount,
4832         'trxn_total_amount' => $trxnParams['total_amount'],
4833         'trxn_id' => $trxnId,
4834       );
4835       self::createProportionalFinancialEntries($entityParams, $lineItems, $ftIds, $taxItems);
4836     }
4837   }
4838
4839   /**
4840    * Checks if line items total amounts
4841    * match the contribution total amount.
4842    *
4843    * @param array $params
4844    *  array of order params.
4845    *
4846    * @throws \API_Exception
4847    */
4848   public static function checkLineItems(&$params) {
4849     $totalAmount = CRM_Utils_Array::value('total_amount', $params);
4850     $lineItemAmount = 0;
4851
4852     foreach ($params['line_items'] as &$lineItems) {
4853       foreach ($lineItems['line_item'] as &$item) {
4854         if (empty($item['financial_type_id'])) {
4855           $item['financial_type_id'] = $params['financial_type_id'];
4856         }
4857         $lineItemAmount += $item['line_total'] + CRM_Utils_Array::value('tax_amount', $item, 0.00);
4858       }
4859     }
4860
4861     if (!isset($totalAmount)) {
4862       $params['total_amount'] = $lineItemAmount;
4863     }
4864     else {
4865       $currency = CRM_Utils_Array::value('currency', $params, '');
4866
4867       if (empty($currency)) {
4868         $currency = CRM_Core_Config::singleton()->defaultCurrency;
4869       }
4870
4871       if (!CRM_Utils_Money::equals($totalAmount, $lineItemAmount, $currency)) {
4872         throw new CRM_Contribute_Exception_CheckLineItemsException();
4873       }
4874     }
4875   }
4876
4877   /**
4878    * Get the financial account for the item associated with the new transaction.
4879    *
4880    * @param array $params
4881    * @param int $default
4882    *
4883    * @return int
4884    */
4885   public static function getFinancialAccountForStatusChangeTrxn($params, $default) {
4886
4887     if (!empty($params['financial_account_id'])) {
4888       return $params['financial_account_id'];
4889     }
4890
4891     $contributionStatus = CRM_Contribute_PseudoConstant::contributionStatus($params['contribution_status_id'], 'name');
4892     $preferredAccountsRelationships = array(
4893       'Refunded' => 'Credit/Contra Revenue Account is',
4894       'Chargeback' => 'Chargeback Account is',
4895     );
4896
4897     if (in_array($contributionStatus, array_keys($preferredAccountsRelationships))) {
4898       $financialTypeID = !empty($params['financial_type_id']) ? $params['financial_type_id'] : $params['prevContribution']->financial_type_id;
4899       return CRM_Financial_BAO_FinancialAccount::getFinancialAccountForFinancialTypeByRelationship(
4900         $financialTypeID,
4901         $preferredAccountsRelationships[$contributionStatus]
4902       );
4903     }
4904
4905     return $default;
4906   }
4907
4908   /**
4909    * ContributionPage values were being imposed onto values.
4910    *
4911    * I have made this explicit and removed the couple (is_recur, is_pay_later) we
4912    * REALLY didn't want superimposed. The rest are left there in their overkill out
4913    * of cautiousness.
4914    *
4915    * The rationale for making this explicit is that it was a case of carefully set values being
4916    * seemingly randonly overwritten without much care. In general I think array randomly setting
4917    * variables en mass is risky.
4918    *
4919    * @param array $values
4920    *
4921    * @return array
4922    */
4923   protected function addContributionPageValuesToValuesHeavyHandedly(&$values) {
4924     $contributionPageValues = array();
4925     CRM_Contribute_BAO_ContributionPage::setValues(
4926       $this->contribution_page_id,
4927       $contributionPageValues
4928     );
4929     $valuesToCopy = array(
4930       // These are the values that I believe to be useful.
4931       'id',
4932       'title',
4933       'pay_later_receipt',
4934       'pay_later_text',
4935       'receipt_from_email',
4936       'receipt_from_name',
4937       'receipt_text',
4938       'custom_pre_id',
4939       'custom_post_id',
4940       'honoree_profile_id',
4941       'onbehalf_profile_id',
4942       'honor_block_is_active',
4943       // Kinda might be - but would be on the contribution...
4944       'campaign_id',
4945       'currency',
4946       // Included for 'fear of regression' but can't justify any use for these....
4947       'intro_text',
4948       'payment_processor',
4949       'financial_type_id',
4950       'amount_block_is_active',
4951       'bcc_receipt',
4952       'cc_receipt',
4953       'created_date',
4954       'created_id',
4955       'default_amount_id',
4956       'end_date',
4957       'footer_text',
4958       'goal_amount',
4959       'initial_amount_help_text',
4960       'initial_amount_label',
4961       'intro_text',
4962       'is_allow_other_amount',
4963       'is_billing_required',
4964       'is_confirm_enabled',
4965       'is_credit_card_only',
4966       'is_monetary',
4967       'is_partial_payment',
4968       'is_recur_installments',
4969       'is_recur_interval',
4970       'is_share',
4971       'max_amount',
4972       'min_amount',
4973       'min_initial_amount',
4974       'recur_frequency_unit',
4975       'start_date',
4976       'thankyou_footer',
4977       'thankyou_text',
4978       'thankyou_title',
4979
4980     );
4981     foreach ($valuesToCopy as $valueToCopy) {
4982       if (isset($contributionPageValues[$valueToCopy])) {
4983         $values[$valueToCopy] = $contributionPageValues[$valueToCopy];
4984       }
4985     }
4986     return $values;
4987   }
4988
4989   /**
4990    * Get values of CiviContribute Settings
4991    * and check if its enabled or not.
4992    * Note: The CiviContribute settings are stored as single entry in civicrm_setting
4993    * in serialized form. Usually this should be stored as flat settings for each form fields
4994    * as per CiviCRM standards. Since this would take more effort to change the current behaviour of CiviContribute
4995    * settings we will live with an inconsistency because it's too hard to change for now.
4996    * https://github.com/civicrm/civicrm-core/pull/8562#issuecomment-227874245
4997    *
4998    *
4999    * @param string $name
5000    * @param bool $checkInvoicing
5001    * @return string
5002    *
5003    */
5004   public static function checkContributeSettings($name = NULL, $checkInvoicing = FALSE) {
5005     $contributeSettings = Civi::settings()->get('contribution_invoice_settings');
5006
5007     if ($checkInvoicing && !CRM_Utils_Array::value('invoicing', $contributeSettings)) {
5008       return NULL;
5009     }
5010
5011     if ($name) {
5012       return CRM_Utils_Array::value($name, $contributeSettings);
5013     }
5014     return $contributeSettings;
5015   }
5016
5017   /**
5018    * This function process contribution related objects.
5019    *
5020    * @param int $contributionId
5021    * @param int $statusId
5022    * @param int|null $previousStatusId
5023    *
5024    * @param string $receiveDate
5025    *
5026    * @return null|string
5027    */
5028   public static function transitionComponentWithReturnMessage($contributionId, $statusId, $previousStatusId = NULL, $receiveDate = NULL) {
5029     $statusMsg = NULL;
5030     if (!$contributionId || !$statusId) {
5031       return $statusMsg;
5032     }
5033
5034     $params = array(
5035       'contribution_id' => $contributionId,
5036       'contribution_status_id' => $statusId,
5037       'previous_contribution_status_id' => $previousStatusId,
5038       'receive_date' => $receiveDate,
5039     );
5040
5041     $updateResult = CRM_Contribute_BAO_Contribution::transitionComponents($params);
5042
5043     if (!is_array($updateResult) ||
5044       !($updatedComponents = CRM_Utils_Array::value('updatedComponents', $updateResult)) ||
5045       !is_array($updatedComponents) ||
5046       empty($updatedComponents)
5047     ) {
5048       return $statusMsg;
5049     }
5050
5051     // get the user display name.
5052     $sql = "
5053    SELECT  display_name as displayName
5054      FROM  civicrm_contact
5055 LEFT JOIN  civicrm_contribution on (civicrm_contribution.contact_id = civicrm_contact.id )
5056     WHERE  civicrm_contribution.id = {$contributionId}";
5057     $userDisplayName = CRM_Core_DAO::singleValueQuery($sql);
5058
5059     // get the status message for user.
5060     foreach ($updatedComponents as $componentName => $updatedStatusId) {
5061
5062       if ($componentName == 'CiviMember') {
5063         $updatedStatusName = CRM_Utils_Array::value($updatedStatusId,
5064           CRM_Member_PseudoConstant::membershipStatus()
5065         );
5066
5067         $statusNameMsgPart = 'updated';
5068         switch ($updatedStatusName) {
5069           case 'Cancelled':
5070           case 'Expired':
5071             $statusNameMsgPart = $updatedStatusName;
5072             break;
5073         }
5074
5075         $statusMsg .= "<br />" . ts("Membership for %1 has been %2.", array(1 => $userDisplayName, 2 => $statusNameMsgPart));
5076       }
5077
5078       if ($componentName == 'CiviEvent') {
5079         $updatedStatusName = CRM_Utils_Array::value($updatedStatusId,
5080           CRM_Event_PseudoConstant::participantStatus()
5081         );
5082         if ($updatedStatusName == 'Cancelled') {
5083           $statusMsg .= "<br />" . ts("Event Registration for %1 has been Cancelled.", array(1 => $userDisplayName));
5084         }
5085         elseif ($updatedStatusName == 'Registered') {
5086           $statusMsg .= "<br />" . ts("Event Registration for %1 has been updated.", array(1 => $userDisplayName));
5087         }
5088       }
5089
5090       if ($componentName == 'CiviPledge') {
5091         $updatedStatusName = CRM_Utils_Array::value($updatedStatusId,
5092           CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name')
5093         );
5094         if ($updatedStatusName == 'Cancelled') {
5095           $statusMsg .= "<br />" . ts("Pledge Payment for %1 has been Cancelled.", array(1 => $userDisplayName));
5096         }
5097         elseif ($updatedStatusName == 'Failed') {
5098           $statusMsg .= "<br />" . ts("Pledge Payment for %1 has been Failed.", array(1 => $userDisplayName));
5099         }
5100         elseif ($updatedStatusName == 'Completed') {
5101           $statusMsg .= "<br />" . ts("Pledge Payment for %1 has been updated.", array(1 => $userDisplayName));
5102         }
5103       }
5104     }
5105
5106     return $statusMsg;
5107   }
5108
5109   /**
5110    * Get the contribution as it is in the database before being updated.
5111    *
5112    * @param int $contributionID
5113    *
5114    * @return \CRM_Contribute_BAO_Contribution|null
5115    */
5116   private static function getOriginalContribution($contributionID) {
5117     return self::getValues(array('id' => $contributionID), CRM_Core_DAO::$_nullArray, CRM_Core_DAO::$_nullArray);
5118   }
5119
5120   /**
5121    * Get the amount for the financial item row.
5122    *
5123    * Helper function to start to break down recordFinancialTransactions for readability.
5124    *
5125    * The logic is more historical than .. logical. Paths other than the deprecated one are tested.
5126    *
5127    * Codewise, several somewhat disimmilar things have been squished into recordFinancialAccounts
5128    * for historical reasons. Going forwards we can hope to add tests & improve readibility
5129    * of that function
5130    *
5131    * @todo move recordFinancialAccounts & helper functions to their own class?
5132    *
5133    * @param array $params
5134    *   Params as passed to contribution.create
5135    *
5136    * @param string $context
5137    *   changeFinancialType| changedAmount
5138    * @param array $lineItemDetails
5139    *   Line items.
5140    * @param bool $isARefund
5141    *   Is this a refund / negative transaction.
5142    *
5143    * @return float
5144    */
5145   protected static function getFinancialItemAmountFromParams($params, $context, $lineItemDetails, $isARefund, $previousLineItemTotal) {
5146     if ($context == 'changedAmount') {
5147       $lineTotal = $lineItemDetails['line_total'];
5148       if ($lineTotal != $previousLineItemTotal) {
5149         $lineTotal -= $previousLineItemTotal;
5150       }
5151       return $lineTotal;
5152     }
5153     elseif ($context == 'changeFinancialType') {
5154       return -$lineItemDetails['line_total'];
5155     }
5156     elseif ($context == 'changedStatus') {
5157       $cancelledTaxAmount = 0;
5158       if ($isARefund) {
5159         $cancelledTaxAmount = CRM_Utils_Array::value('tax_amount', $lineItemDetails, '0.00');
5160       }
5161       return self::getMultiplier($params['contribution']->contribution_status_id, $context) * ((float) $lineItemDetails['line_total'] + (float) $cancelledTaxAmount);
5162     }
5163     elseif ($context === NULL) {
5164       // erm, yes because? but, hey, it's tested.
5165       return $lineItemDetails['line_total'];
5166     }
5167     elseif (empty($lineItemDetails['line_total'])) {
5168       // follow legacy code path
5169       Civi::log()
5170         ->warning('Deprecated bit of code, please log a ticket explaining how you got here!', array('civi.tag' => 'deprecated'));
5171       return $params['total_amount'];
5172     }
5173     else {
5174       return self::getMultiplier($params['contribution']->contribution_status_id, $context) * ((float) $lineItemDetails['line_total']);
5175     }
5176   }
5177
5178   /**
5179    * Get the multiplier for adjusting rows.
5180    *
5181    * If we are dealing with a refund or cancellation then it will be a negative
5182    * amount to reflect the negative transaction.
5183    *
5184    * If we are changing Financial Type it will be a negative amount to
5185    * adjust down the old type.
5186    *
5187    * @param int $contribution_status_id
5188    * @param string $context
5189    *
5190    * @return int
5191    */
5192   protected static function getMultiplier($contribution_status_id, $context) {
5193     if ($context == 'changeFinancialType' || self::isContributionStatusNegative($contribution_status_id)) {
5194       return -1;
5195     }
5196     return 1;
5197   }
5198
5199   /**
5200    * Does this transaction reflect a payment instrument change.
5201    *
5202    * @param array $params
5203    * @param array $pendingStatuses
5204    *
5205    * @return bool
5206    */
5207   protected static function isPaymentInstrumentChange(&$params, $pendingStatuses) {
5208     $contributionStatus = CRM_Core_PseudoConstant::getName('CRM_Contribute_BAO_Contribution', 'contribution_status_id', $params['contribution']->contribution_status_id);
5209
5210     if (array_key_exists('payment_instrument_id', $params)) {
5211       if (CRM_Utils_System::isNull($params['prevContribution']->payment_instrument_id) &&
5212         !CRM_Utils_System::isNull($params['payment_instrument_id'])
5213       ) {
5214         //check if status is changed from Pending to Completed
5215         // do not update payment instrument changes for Pending to Completed
5216         if (!($contributionStatus == 'Completed' &&
5217           in_array($params['prevContribution']->contribution_status_id, $pendingStatuses))
5218         ) {
5219           return TRUE;
5220         }
5221       }
5222       elseif ((!CRM_Utils_System::isNull($params['payment_instrument_id']) &&
5223           !CRM_Utils_System::isNull($params['prevContribution']->payment_instrument_id)) &&
5224         $params['payment_instrument_id'] != $params['prevContribution']->payment_instrument_id
5225       ) {
5226         return TRUE;
5227       }
5228       elseif (!CRM_Utils_System::isNull($params['contribution']->check_number) &&
5229         $params['contribution']->check_number != $params['prevContribution']->check_number
5230       ) {
5231         // another special case when check number is changed, create new financial records
5232         // create financial trxn with negative amount
5233         return TRUE;
5234       }
5235     }
5236     return FALSE;
5237   }
5238
5239   /**
5240    * Update the memberships associated with a contribution if it has been completed.
5241    *
5242    * Note that the way in which $memberships are loaded as objects is pretty messy & I think we could just
5243    * load them in this function. Code clean up would compensate for any minor performance implication.
5244    *
5245    * @param \CRM_Contribute_BAO_Contribution $contribution
5246    * @param int $primaryContributionID
5247    * @param string $changeDate
5248    *
5249    * @throws \CRM_Core_Exception
5250    * @throws \CiviCRM_API3_Exception
5251    */
5252   public static function updateMembershipBasedOnCompletionOfContribution($contribution, $primaryContributionID, $changeDate) {
5253     $memberships = self::getRelatedMemberships($contribution->id);
5254     foreach ($memberships as $membership) {
5255       $membershipParams = array(
5256         'id' => $membership['id'],
5257         'contact_id' => $membership['contact_id'],
5258         'is_test' => $membership['is_test'],
5259         'membership_type_id' => $membership['membership_type_id'],
5260         'membership_activity_status' => 'Completed',
5261       );
5262
5263       $currentMembership = CRM_Member_BAO_Membership::getContactMembership($membershipParams['contact_id'],
5264         $membershipParams['membership_type_id'],
5265         $membershipParams['is_test'],
5266         $membershipParams['id']
5267       );
5268
5269       // CRM-8141 update the membership type with the value recorded in log when membership created/renewed
5270       // this picks up membership type changes during renewals
5271       // @todo this is almost certainly an obsolete sql call, the pre-change
5272       // membership is accessible via $this->_relatedObjects
5273       $sql = "
5274 SELECT    membership_type_id
5275 FROM      civicrm_membership_log
5276 WHERE     membership_id={$membershipParams['id']}
5277 ORDER BY  id DESC
5278 LIMIT 1;";
5279       $dao = CRM_Core_DAO::executeQuery($sql);
5280       if ($dao->fetch()) {
5281         if (!empty($dao->membership_type_id)) {
5282           $membershipParams['membership_type_id'] = $dao->membership_type_id;
5283         }
5284       }
5285
5286       $membershipParams['num_terms'] = $contribution->getNumTermsByContributionAndMembershipType(
5287         $membershipParams['membership_type_id'],
5288         $primaryContributionID
5289       );
5290       // @todo remove all this stuff in favour of letting the api call further down handle in
5291       // (it is a duplication of what the api does).
5292       $dates = array_fill_keys(array(
5293         'join_date',
5294         'start_date',
5295         'end_date',
5296       ), NULL);
5297       if ($currentMembership) {
5298         /*
5299          * Fixed FOR CRM-4433
5300          * In BAO/Membership.php(renewMembership function), we skip the extend membership date and status
5301          * when Contribution mode is notify and membership is for renewal )
5302          */
5303         CRM_Member_BAO_Membership::fixMembershipStatusBeforeRenew($currentMembership, $changeDate);
5304
5305         // @todo - we should pass membership_type_id instead of null here but not
5306         // adding as not sure of testing
5307         $dates = CRM_Member_BAO_MembershipType::getRenewalDatesForMembershipType($membershipParams['id'],
5308           $changeDate, NULL, $membershipParams['num_terms']
5309         );
5310         $dates['join_date'] = $currentMembership['join_date'];
5311       }
5312
5313       //get the status for membership.
5314       $calcStatus = CRM_Member_BAO_MembershipStatus::getMembershipStatusByDate($dates['start_date'],
5315         $dates['end_date'],
5316         $dates['join_date'],
5317         'today',
5318         TRUE,
5319         $membershipParams['membership_type_id'],
5320         $membershipParams
5321       );
5322
5323       unset($dates['end_date']);
5324       $membershipParams['status_id'] = CRM_Utils_Array::value('id', $calcStatus, 'New');
5325       //we might be renewing membership,
5326       //so make status override false.
5327       $membershipParams['is_override'] = FALSE;
5328       $membershipParams['status_override_end_date'] = 'null';
5329
5330       //CRM-17723 - reset static $relatedContactIds array()
5331       // @todo move it to Civi Statics.
5332       $var = TRUE;
5333       CRM_Member_BAO_Membership::createRelatedMemberships($var, $var, TRUE);
5334       civicrm_api3('Membership', 'create', $membershipParams);
5335     }
5336   }
5337
5338   /**
5339    * Get payment links as they relate to a contribution.
5340    *
5341    * If a payment can be made then include a payment link & if a refund is appropriate
5342    * then a refund link.
5343    *
5344    * @param int $id
5345    * @param float $balance
5346    * @param string $contributionStatus
5347    *
5348    * @return array $actionLinks Links array containing:
5349    *   -url
5350    *   -title
5351    */
5352   protected static function getContributionPaymentLinks($id, $balance, $contributionStatus) {
5353     if ($contributionStatus === 'Failed' || !CRM_Core_Permission::check('edit contributions')) {
5354       // In general the balance is the best way to determine if a payment can be added or not,
5355       // but not for Failed contributions, where we don't accept additional payments at the moment.
5356       // (in some cases the contribution is 'Pending' and only the payment is failed. In those we
5357       // do accept more payments agains them.
5358       return array();
5359     }
5360     $actionLinks = array();
5361     if ((int) $balance > 0) {
5362       if (CRM_Core_Config::isEnabledBackOfficeCreditCardPayments()) {
5363         $actionLinks[] = array(
5364           'url' => CRM_Utils_System::url('civicrm/payment', array(
5365             'action' => 'add',
5366             'reset' => 1,
5367             'id' => $id,
5368             'mode' => 'live',
5369           )),
5370           'title' => ts('Submit Credit Card payment'),
5371         );
5372       }
5373       $actionLinks[] = array(
5374         'url' => CRM_Utils_System::url('civicrm/payment', array(
5375           'action' => 'add',
5376           'reset' => 1,
5377           'id' => $id,
5378         )),
5379         'title' => ts('Record Payment'),
5380       );
5381     }
5382     elseif ((int) $balance < 0) {
5383       $actionLinks[] = array(
5384         'url' => CRM_Utils_System::url('civicrm/payment', array(
5385           'action' => 'add',
5386           'reset' => 1,
5387           'id' => $id,
5388         )),
5389         'title' => ts('Record Refund'),
5390       );
5391     }
5392     return $actionLinks;
5393   }
5394
5395   /**
5396    * Get a query to determine the amount donated by the contact/s in the current financial year.
5397    *
5398    * @param array $contactIDs
5399    *
5400    * @return string
5401    */
5402   public static function getAnnualQuery($contactIDs) {
5403     $contactIDs = implode(',', $contactIDs);
5404     $config = CRM_Core_Config::singleton();
5405     $currentMonth = date('m');
5406     $currentDay = date('d');
5407     if (
5408       (int) $config->fiscalYearStart['M'] > $currentMonth ||
5409       (
5410         (int) $config->fiscalYearStart['M'] == $currentMonth &&
5411         (int) $config->fiscalYearStart['d'] > $currentDay
5412       )
5413     ) {
5414       $year = date('Y') - 1;
5415     }
5416     else {
5417       $year = date('Y');
5418     }
5419     $nextYear = $year + 1;
5420
5421     if ($config->fiscalYearStart) {
5422       $newFiscalYearStart = $config->fiscalYearStart;
5423       if ($newFiscalYearStart['M'] < 10) {
5424         // This is just a clumsy way of adding padding.
5425         // @todo next round look for a nicer way.
5426         $newFiscalYearStart['M'] = '0' . $newFiscalYearStart['M'];
5427       }
5428       if ($newFiscalYearStart['d'] < 10) {
5429         // This is just a clumsy way of adding padding.
5430         // @todo next round look for a nicer way.
5431         $newFiscalYearStart['d'] = '0' . $newFiscalYearStart['d'];
5432       }
5433       $config->fiscalYearStart = $newFiscalYearStart;
5434       $monthDay = $config->fiscalYearStart['M'] . $config->fiscalYearStart['d'];
5435     }
5436     else {
5437       // First of January.
5438       $monthDay = '0101';
5439     }
5440     $startDate = "$year$monthDay";
5441     $endDate = "$nextYear$monthDay";
5442
5443     $whereClauses = [
5444       'contact_id' => 'IN (' . $contactIDs . ')',
5445       'is_test' => ' = 0',
5446       'receive_date' => ['>=' . $startDate, '<  ' . $endDate],
5447     ];
5448     $havingClause = 'contribution_status_id = ' . (int) CRM_Core_PseudoConstant::getKey('CRM_Contribute_BAO_Contribution', 'contribution_status_id', 'Completed');
5449     CRM_Financial_BAO_FinancialType::addACLClausesToWhereClauses($whereClauses);
5450
5451     $clauses = [];
5452     foreach ($whereClauses as $key => $clause) {
5453       $clauses[] = 'b.' . $key . " "  . implode(' AND b.' . $key, (array) $clause);
5454     }
5455     $whereClauseString = implode(' AND ', $clauses);
5456
5457     // See https://github.com/civicrm/civicrm-core/pull/13512 for discussion of how
5458     // this group by + having on contribution_status_id improves performance
5459     $query = "
5460       SELECT COUNT(*) as count,
5461              SUM(total_amount) as amount,
5462              AVG(total_amount) as average,
5463              currency
5464       FROM civicrm_contribution b
5465       WHERE " . $whereClauseString . "
5466       GROUP BY currency, contribution_status_id
5467       HAVING $havingClause
5468       ";
5469     return $query;
5470   }
5471
5472   /**
5473    * Assign Test Value.
5474    *
5475    * @param string $fieldName
5476    * @param array $fieldDef
5477    * @param int $counter
5478    */
5479   protected function assignTestValue($fieldName, &$fieldDef, $counter) {
5480     if ($fieldName == 'tax_amount') {
5481       $this->{$fieldName} = "0.00";
5482     }
5483     elseif ($fieldName == 'net_amount') {
5484       $this->{$fieldName} = "2.00";
5485     }
5486     elseif ($fieldName == 'total_amount') {
5487       $this->{$fieldName} = "3.00";
5488     }
5489     elseif ($fieldName == 'fee_amount') {
5490       $this->{$fieldName} = "1.00";
5491     }
5492     else {
5493       parent::assignTestValues($fieldName, $fieldDef, $counter);
5494     }
5495   }
5496
5497   /**
5498    * Check if contribution has participant/membership payment.
5499    *
5500    * @param int $contributionId
5501    *   Contribution ID
5502    *
5503    * @return bool
5504    */
5505   public static function allowUpdateRevenueRecognitionDate($contributionId) {
5506     // get line item for contribution
5507     $lineItems = CRM_Price_BAO_LineItem::getLineItemsByContributionID($contributionId);
5508     // check if line item is for membership or participant
5509     foreach ($lineItems as $items) {
5510       if ($items['entity_table'] == 'civicrm_participant') {
5511         $flag = FALSE;
5512         break;
5513       }
5514       elseif ($items['entity_table'] == 'civicrm_membership') {
5515         $flag = FALSE;
5516       }
5517       else {
5518         $flag = TRUE;
5519         break;
5520       }
5521     }
5522     return $flag;
5523   }
5524
5525   /**
5526    * Create Accounts Receivable financial trxn entry for Completed Contribution.
5527    *
5528    * @param array $trxnParams
5529    *   Financial trxn params
5530    * @param array $contributionParams
5531    *   Contribution Params
5532    *
5533    * @return null
5534    */
5535   public static function recordAlwaysAccountsReceivable(&$trxnParams, $contributionParams) {
5536     if (!self::checkContributeSettings('always_post_to_accounts_receivable')) {
5537       return NULL;
5538     }
5539     $statusId = $contributionParams['contribution']->contribution_status_id;
5540     $contributionStatuses = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
5541     $contributionStatus = empty($statusId) ? NULL : $contributionStatuses[$statusId];
5542     $previousContributionStatus = empty($contributionParams['prevContribution']) ? NULL : $contributionStatuses[$contributionParams['prevContribution']->contribution_status_id];
5543     // Return if contribution status is not completed.
5544     if (!($contributionStatus == 'Completed' && (empty($previousContributionStatus)
5545       || (!empty($previousContributionStatus) && $previousContributionStatus == 'Pending'
5546         && $contributionParams['prevContribution']->is_pay_later == 0
5547       )))
5548     ) {
5549       return NULL;
5550     }
5551
5552     $params = $trxnParams;
5553     $financialTypeID = CRM_Utils_Array::value('financial_type_id', $contributionParams) ? $contributionParams['financial_type_id'] : $contributionParams['prevContribution']->financial_type_id;
5554     $arAccountId = CRM_Contribute_PseudoConstant::getRelationalFinancialAccount($financialTypeID, 'Accounts Receivable Account is');
5555     $params['to_financial_account_id'] = $arAccountId;
5556     $params['status_id'] = array_search('Pending', $contributionStatuses);
5557     $params['is_payment'] = FALSE;
5558     $trxn = CRM_Core_BAO_FinancialTrxn::create($params);
5559     self::$_trxnIDs[] = $trxn->id;
5560     $trxnParams['from_financial_account_id'] = $params['to_financial_account_id'];
5561   }
5562
5563   /**
5564    * Calculate financial item amount when contribution is updated.
5565    *
5566    * @param array $params
5567    *   contribution params
5568    * @param array $amountParams
5569    *
5570    * @param string $context
5571    *
5572    * @return float
5573    */
5574   public static function calculateFinancialItemAmount($params, $amountParams, $context) {
5575     if (!empty($params['is_quick_config'])) {
5576       $amount = $amountParams['item_amount'];
5577       if (!$amount) {
5578         $amount = $params['total_amount'];
5579         if ($context === NULL) {
5580           $amount -= CRM_Utils_Array::value('tax_amount', $params, 0);
5581         }
5582       }
5583     }
5584     else {
5585       $amount = $amountParams['line_total'];
5586       if ($context == 'changedAmount') {
5587         $amount -= $amountParams['previous_line_total'];
5588       }
5589       $amount *= $amountParams['diff'];
5590     }
5591     return $amount;
5592   }
5593
5594   /**
5595    * Retrieve Sales Tax Financial Accounts.
5596    *
5597    *
5598    * @return array
5599    *
5600    */
5601   public static function getSalesTaxFinancialAccounts() {
5602     $query = "SELECT cfa.id FROM civicrm_entity_financial_account ce
5603  INNER JOIN civicrm_financial_account cfa ON ce.financial_account_id = cfa.id
5604  WHERE `entity_table` = 'civicrm_financial_type' AND cfa.is_tax = 1 AND ce.account_relationship = %1 GROUP BY cfa.id";
5605     $accountRel = key(CRM_Core_PseudoConstant::accountOptionValues('account_relationship', NULL, " AND v.name LIKE 'Sales Tax Account is' "));
5606     $queryParams = array(1 => array($accountRel, 'Integer'));
5607     $dao = CRM_Core_DAO::executeQuery($query, $queryParams);
5608     $financialAccount = array();
5609     while ($dao->fetch()) {
5610       $financialAccount[$dao->id] = $dao->id;
5611     }
5612     return $financialAccount;
5613   }
5614
5615   /**
5616    * Create tax entry in civicrm_entity_financial_trxn table.
5617    *
5618    * @param array $entityParams
5619    *
5620    * @param array $eftParams
5621    *
5622    */
5623   public static function createProportionalEntry($entityParams, $eftParams) {
5624     $paid = 0;
5625     if ($entityParams['contribution_total_amount'] != 0) {
5626       $paid = $entityParams['line_item_amount'] * ($entityParams['trxn_total_amount'] / $entityParams['contribution_total_amount']);
5627     }
5628     // Record Entity Financial Trxn; CRM-20145
5629     $eftParams['amount'] = CRM_Contribute_BAO_Contribution_Utils::formatAmount($paid);
5630     civicrm_api3('EntityFinancialTrxn', 'create', $eftParams);
5631   }
5632
5633   /**
5634    * Create array of last financial item id's.
5635    *
5636    * @param int $contributionId
5637    *
5638    * @return array
5639    */
5640   public static function getLastFinancialItemIds($contributionId) {
5641     $sql = "SELECT fi.id, li.price_field_value_id, li.tax_amount, fi.financial_account_id
5642       FROM civicrm_financial_item fi
5643       INNER JOIN civicrm_line_item li ON li.id = fi.entity_id and fi.entity_table = 'civicrm_line_item'
5644       WHERE li.contribution_id = %1";
5645     $dao = CRM_Core_DAO::executeQuery($sql, array(1 => array($contributionId, 'Integer')));
5646     $ftIds = $taxItems = array();
5647     $salesTaxFinancialAccount = self::getSalesTaxFinancialAccounts();
5648     while ($dao->fetch()) {
5649       /* if sales tax item*/
5650       if (in_array($dao->financial_account_id, $salesTaxFinancialAccount)) {
5651         $taxItems[$dao->price_field_value_id] = array(
5652           'financial_item_id' => $dao->id,
5653           'amount' => $dao->tax_amount,
5654         );
5655       }
5656       else {
5657         $ftIds[$dao->price_field_value_id] = $dao->id;
5658       }
5659     }
5660     return array($ftIds, $taxItems);
5661   }
5662
5663   /**
5664    * Create proportional entries in civicrm_entity_financial_trxn.
5665    *
5666    * @param array $entityParams
5667    *
5668    * @param array $lineItems
5669    *
5670    * @param array $ftIds
5671    *
5672    * @param array $taxItems
5673    *
5674    */
5675   public static function createProportionalFinancialEntries($entityParams, $lineItems, $ftIds, $taxItems) {
5676     $eftParams = array(
5677       'entity_table' => 'civicrm_financial_item',
5678       'financial_trxn_id' => $entityParams['trxn_id'],
5679     );
5680     foreach ($lineItems as $key => $value) {
5681       if ($value['qty'] == 0) {
5682         continue;
5683       }
5684       $eftParams['entity_id'] = $ftIds[$value['price_field_value_id']];
5685       $entityParams['line_item_amount'] = $value['line_total'];
5686       self::createProportionalEntry($entityParams, $eftParams);
5687       if (array_key_exists($value['price_field_value_id'], $taxItems)) {
5688         $entityParams['line_item_amount'] = $taxItems[$value['price_field_value_id']]['amount'];
5689         $eftParams['entity_id'] = $taxItems[$value['price_field_value_id']]['financial_item_id'];
5690         self::createProportionalEntry($entityParams, $eftParams);
5691       }
5692     }
5693   }
5694
5695   /**
5696    * Load entities related to the contribution into $this->_relatedObjects.
5697    *
5698    * @param array $ids
5699    *
5700    * @throws \CRM_Core_Exception
5701    */
5702   protected function loadRelatedEntitiesByID($ids) {
5703     $entities = array(
5704       'contact' => 'CRM_Contact_BAO_Contact',
5705       'contributionRecur' => 'CRM_Contribute_BAO_ContributionRecur',
5706       'contributionType' => 'CRM_Financial_BAO_FinancialType',
5707       'financialType' => 'CRM_Financial_BAO_FinancialType',
5708       'contributionPage' => 'CRM_Contribute_BAO_ContributionPage',
5709     );
5710     foreach ($entities as $entity => $bao) {
5711       if (!empty($ids[$entity])) {
5712         $this->_relatedObjects[$entity] = new $bao();
5713         $this->_relatedObjects[$entity]->id = $ids[$entity];
5714         if (!$this->_relatedObjects[$entity]->find(TRUE)) {
5715           throw new CRM_Core_Exception($entity . ' could not be loaded');
5716         }
5717       }
5718     }
5719   }
5720
5721   /**
5722    * Should an email receipt be sent for this contribution when complete.
5723    *
5724    * @param array $input
5725    *
5726    * @return mixed
5727    */
5728   protected function isEmailReceipt($input) {
5729     if (isset($input['is_email_receipt'])) {
5730       return $input['is_email_receipt'];
5731     }
5732     if (!empty($this->_relatedObjects['contribution_page_id'])) {
5733       return $this->_relatedObjects['contribution_page_id']->is_email_receipt;
5734     }
5735     return TRUE;
5736   }
5737
5738   /**
5739    * Function to replace contribution tokens.
5740    *
5741    * @param array $contributionIds
5742    *
5743    * @param string $subject
5744    *
5745    * @param array $subjectToken
5746    *
5747    * @param string $text
5748    *
5749    * @param string $html
5750    *
5751    * @param array $messageToken
5752    *
5753    * @param bool $escapeSmarty
5754    *
5755    * @return array
5756    */
5757   public static function replaceContributionTokens(
5758     $contributionIds,
5759     $subject,
5760     $subjectToken,
5761     $text,
5762     $html,
5763     $messageToken,
5764     $escapeSmarty
5765   ) {
5766     if (empty($contributionIds)) {
5767       return array();
5768     }
5769     $contributionDetails = array();
5770     foreach ($contributionIds as $id) {
5771       $result = civicrm_api3('Contribution', 'get', array('id' => $id));
5772       $contributionDetails[$result['values'][$result['id']]['contact_id']]['subject'] = CRM_Utils_Token::replaceContributionTokens($subject, $result, FALSE, $subjectToken, FALSE, $escapeSmarty);
5773       $contributionDetails[$result['values'][$result['id']]['contact_id']]['text'] = CRM_Utils_Token::replaceContributionTokens($text, $result, FALSE, $messageToken, FALSE, $escapeSmarty);
5774       $contributionDetails[$result['values'][$result['id']]['contact_id']]['html'] = CRM_Utils_Token::replaceContributionTokens($html, $result, FALSE, $messageToken, FALSE, $escapeSmarty);
5775     }
5776     return $contributionDetails;
5777   }
5778
5779   /**
5780    * Get invoice_number for contribution.
5781    *
5782    * @param int $contributionID
5783    *
5784    * @return string
5785    */
5786   public static function getInvoiceNumber($contributionID) {
5787     if ($invoicePrefix = self::checkContributeSettings('invoice_prefix', TRUE)) {
5788       return $invoicePrefix . $contributionID;
5789     }
5790
5791     return NULL;
5792   }
5793
5794 }