CRM/Contribute/BAO/Contribution.php

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